content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package io.nekohasekai.sagernet.ui
import androidx.fragment.app.Fragment
abstract class NamedFragment : Fragment {
constructor() : super()
constructor(contentLayoutId: Int) : super(contentLayoutId)
private val name by lazy { name0() }
fun name() = name
protected abstract fun name0(): String
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/NamedFragment.kt | 3435000715 |
package io.nekohasekai.sagernet.ui
import android.Manifest
import android.Manifest.permission.POST_NOTIFICATIONS
import android.annotation.SuppressLint
import android.content.Intent
import android.content.pm.PackageManager
import android.graphics.Color
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.RemoteException
import android.view.KeyEvent
import android.view.MenuItem
import androidx.activity.addCallback
import androidx.annotation.IdRes
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.core.view.ViewCompat
import androidx.preference.PreferenceDataStore
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.google.android.material.navigation.NavigationView
import com.google.android.material.snackbar.Snackbar
import io.nekohasekai.sagernet.GroupType
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.aidl.ISagerNetService
import io.nekohasekai.sagernet.aidl.SpeedDisplayData
import io.nekohasekai.sagernet.aidl.TrafficData
import io.nekohasekai.sagernet.bg.BaseService
import io.nekohasekai.sagernet.bg.SagerConnection
import io.nekohasekai.sagernet.database.*
import io.nekohasekai.sagernet.database.preference.OnPreferenceDataStoreChangeListener
import io.nekohasekai.sagernet.databinding.LayoutMainBinding
import io.nekohasekai.sagernet.fmt.AbstractBean
import io.nekohasekai.sagernet.fmt.KryoConverters
import io.nekohasekai.sagernet.fmt.PluginEntry
import io.nekohasekai.sagernet.group.GroupInterfaceAdapter
import io.nekohasekai.sagernet.group.GroupUpdater
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.widget.ListHolderListener
import moe.matsuri.nb4a.utils.Util
import java.io.File
class MainActivity : ThemedActivity(),
SagerConnection.Callback,
OnPreferenceDataStoreChangeListener,
NavigationView.OnNavigationItemSelectedListener {
lateinit var binding: LayoutMainBinding
lateinit var navigation: NavigationView
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
window?.apply {
statusBarColor = Color.TRANSPARENT
}
binding = LayoutMainBinding.inflate(layoutInflater)
binding.fab.initProgress(binding.fabProgress)
if (themeResId !in intArrayOf(
R.style.Theme_SagerNet_Black
)
) {
navigation = binding.navView
binding.drawerLayout.removeView(binding.navViewBlack)
} else {
navigation = binding.navViewBlack
binding.drawerLayout.removeView(binding.navView)
}
navigation.setNavigationItemSelectedListener(this)
if (savedInstanceState == null) {
displayFragmentWithId(R.id.nav_configuration)
}
onBackPressedDispatcher.addCallback {
if (supportFragmentManager.findFragmentById(R.id.fragment_holder) is ConfigurationFragment) {
moveTaskToBack(true)
} else {
displayFragmentWithId(R.id.nav_configuration)
}
}
binding.fab.setOnClickListener {
if (DataStore.serviceState.canStop) SagerNet.stopService() else connect.launch(
null
)
}
binding.stats.setOnClickListener { if (DataStore.serviceState.connected) binding.stats.testConnection() }
setContentView(binding.root)
ViewCompat.setOnApplyWindowInsetsListener(binding.coordinator, ListHolderListener)
changeState(BaseService.State.Idle)
connection.connect(this, this)
DataStore.configurationStore.registerChangeListener(this)
GroupManager.userInterface = GroupInterfaceAdapter(this)
if (intent?.action == Intent.ACTION_VIEW) {
onNewIntent(intent)
}
refreshNavMenu(!DataStore.clashAPIListen.isNullOrBlank())
// sdk 33 notification
if (Build.VERSION.SDK_INT >= 33) {
val checkPermission =
ContextCompat.checkSelfPermission(this@MainActivity, POST_NOTIFICATIONS)
if (checkPermission != PackageManager.PERMISSION_GRANTED) {
//动态申请
ActivityCompat.requestPermissions(
this@MainActivity,
arrayOf(POST_NOTIFICATIONS),
0
)
}
}
if (ContextCompat.checkSelfPermission(
this, Manifest.permission.ACCESS_FINE_LOCATION
) != PackageManager.PERMISSION_GRANTED
) {
if (!ActivityCompat.shouldShowRequestPermissionRationale(
this, Manifest.permission.ACCESS_FINE_LOCATION
)
) {
ActivityCompat.requestPermissions(
this@MainActivity,
arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),
0
)
}
}
// consent
try {
val f = File(application.filesDir, "consent")
if (!f.exists()) {
MaterialAlertDialogBuilder(this@MainActivity)
.setTitle("VpnService policy")
.setMessage("Since the main function of this application is VPN, it must use VpnService.")
.setPositiveButton(R.string.yes) { _, _ ->
f.createNewFile()
}
.setNegativeButton(android.R.string.cancel) { _, _ ->
finish()
}
.show()
}
} catch (e: Exception) {
Logs.w(e)
}
}
fun refreshNavMenu(clashApi: Boolean) {
if (::navigation.isInitialized) {
navigation.menu.findItem(R.id.nav_traffic)?.isVisible = clashApi
}
}
override fun onNewIntent(intent: Intent) {
super.onNewIntent(intent)
val uri = intent.data ?: return
runOnDefaultDispatcher {
if (uri.scheme == "sn" && uri.host == "subscription" || uri.scheme == "clash") {
importSubscription(uri)
} else {
importProfile(uri)
}
}
}
fun urlTest(): Int {
if (!DataStore.serviceState.connected || connection.service == null) {
error("not started")
}
return connection.service!!.urlTest()
}
suspend fun importSubscription(uri: Uri) {
val group: ProxyGroup
val url = uri.getQueryParameter("url")
if (!url.isNullOrBlank()) {
group = ProxyGroup(type = GroupType.SUBSCRIPTION)
val subscription = SubscriptionBean()
group.subscription = subscription
// cleartext format
subscription.link = url
group.name = uri.getQueryParameter("name")
} else {
val data = uri.encodedQuery.takeIf { !it.isNullOrBlank() } ?: return
try {
group = KryoConverters.deserialize(
ProxyGroup().apply { export = true }, Util.zlibDecompress(Util.b64Decode(data))
).apply {
export = false
}
} catch (e: Exception) {
onMainDispatcher {
alert(e.readableMessage).show()
}
return
}
}
val name = group.name.takeIf { !it.isNullOrBlank() } ?: group.subscription?.link
?: group.subscription?.token
if (name.isNullOrBlank()) return
group.name = group.name.takeIf { !it.isNullOrBlank() }
?: ("Subscription #" + System.currentTimeMillis())
onMainDispatcher {
displayFragmentWithId(R.id.nav_group)
MaterialAlertDialogBuilder(this@MainActivity).setTitle(R.string.subscription_import)
.setMessage(getString(R.string.subscription_import_message, name))
.setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
finishImportSubscription(group)
}
}
.setNegativeButton(android.R.string.cancel, null)
.show()
}
}
private suspend fun finishImportSubscription(subscription: ProxyGroup) {
GroupManager.createGroup(subscription)
GroupUpdater.startUpdate(subscription, true)
}
suspend fun importProfile(uri: Uri) {
val profile = try {
parseProxies(uri.toString()).getOrNull(0) ?: error(getString(R.string.no_proxies_found))
} catch (e: Exception) {
onMainDispatcher {
alert(e.readableMessage).show()
}
return
}
onMainDispatcher {
MaterialAlertDialogBuilder(this@MainActivity).setTitle(R.string.profile_import)
.setMessage(getString(R.string.profile_import_message, profile.displayName()))
.setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
finishImportProfile(profile)
}
}
.setNegativeButton(android.R.string.cancel, null)
.show()
}
}
private suspend fun finishImportProfile(profile: AbstractBean) {
val targetId = DataStore.selectedGroupForImport()
ProfileManager.createProfile(targetId, profile)
onMainDispatcher {
displayFragmentWithId(R.id.nav_configuration)
snackbar(resources.getQuantityString(R.plurals.added, 1, 1)).show()
}
}
override fun missingPlugin(profileName: String, pluginName: String) {
val pluginEntity = PluginEntry.find(pluginName)
// unknown exe or neko plugin
if (pluginEntity == null) {
snackbar(getString(R.string.plugin_unknown, pluginName)).show()
return
}
// official exe
MaterialAlertDialogBuilder(this).setTitle(R.string.missing_plugin)
.setMessage(
getString(
R.string.profile_requiring_plugin, profileName, pluginEntity.displayName
)
)
.setPositiveButton(R.string.action_download) { _, _ ->
showDownloadDialog(pluginEntity)
}
.setNeutralButton(android.R.string.cancel, null)
.setNeutralButton(R.string.action_learn_more) { _, _ ->
launchCustomTab("https://AntiNeko.github.io/m-plugin/")
}
.show()
}
private fun showDownloadDialog(pluginEntry: PluginEntry) {
var index = 0
var playIndex = -1
var fdroidIndex = -1
val items = mutableListOf<String>()
if (pluginEntry.downloadSource.playStore) {
items.add(getString(R.string.install_from_play_store))
playIndex = index++
}
if (pluginEntry.downloadSource.fdroid) {
items.add(getString(R.string.install_from_fdroid))
fdroidIndex = index++
}
items.add(getString(R.string.download))
val downloadIndex = index
MaterialAlertDialogBuilder(this).setTitle(pluginEntry.name)
.setItems(items.toTypedArray()) { _, which ->
when (which) {
playIndex -> launchCustomTab("https://play.google.com/store/apps/details?id=${pluginEntry.packageName}")
fdroidIndex -> launchCustomTab("https://f-droid.org/packages/${pluginEntry.packageName}/")
downloadIndex -> launchCustomTab(pluginEntry.downloadSource.downloadLink)
}
}
.show()
}
override fun onNavigationItemSelected(item: MenuItem): Boolean {
if (item.isChecked) binding.drawerLayout.closeDrawers() else {
return displayFragmentWithId(item.itemId)
}
return true
}
@SuppressLint("CommitTransaction")
fun displayFragment(fragment: ToolbarFragment) {
if (fragment is ConfigurationFragment) {
binding.stats.allowShow = true
binding.fab.show()
} else if (!DataStore.showBottomBar) {
binding.stats.allowShow = false
binding.stats.performHide()
binding.fab.hide()
}
supportFragmentManager.beginTransaction()
.replace(R.id.fragment_holder, fragment)
.commitAllowingStateLoss()
binding.drawerLayout.closeDrawers()
}
fun displayFragmentWithId(@IdRes id: Int): Boolean {
when (id) {
R.id.nav_configuration -> {
displayFragment(ConfigurationFragment())
}
R.id.nav_group -> displayFragment(GroupFragment())
R.id.nav_route -> displayFragment(RouteFragment())
R.id.nav_settings -> displayFragment(SettingsFragment())
R.id.nav_traffic -> displayFragment(WebviewFragment())
R.id.nav_tools -> displayFragment(ToolsFragment())
R.id.nav_logcat -> displayFragment(LogcatFragment())
R.id.nav_faq -> {
launchCustomTab("https://AntiNeko.github.io")
return false
}
R.id.nav_about -> displayFragment(AboutFragment())
else -> return false
}
navigation.menu.findItem(id).isChecked = true
return true
}
private fun changeState(
state: BaseService.State,
msg: String? = null,
animate: Boolean = false,
) {
DataStore.serviceState = state
binding.fab.changeState(state, DataStore.serviceState, animate)
binding.stats.changeState(state)
if (msg != null) snackbar(getString(R.string.vpn_error, msg)).show()
}
override fun snackbarInternal(text: CharSequence): Snackbar {
return Snackbar.make(binding.coordinator, text, Snackbar.LENGTH_LONG).apply {
if (binding.fab.isShown) {
anchorView = binding.fab
}
// TODO
}
}
override fun stateChanged(state: BaseService.State, profileName: String?, msg: String?) {
changeState(state, msg, true)
}
val connection = SagerConnection(SagerConnection.CONNECTION_ID_MAIN_ACTIVITY_FOREGROUND, true)
override fun onServiceConnected(service: ISagerNetService) = changeState(
try {
BaseService.State.entries[service.state]
} catch (_: RemoteException) {
BaseService.State.Idle
}
)
override fun onServiceDisconnected() = changeState(BaseService.State.Idle)
override fun onBinderDied() {
connection.disconnect(this)
connection.connect(this, this)
}
private val connect = registerForActivityResult(VpnRequestActivity.StartService()) {
if (it) snackbar(R.string.vpn_permission_denied).show()
}
// may NOT called when app is in background
// ONLY do UI update here, write DB in bg process
override fun cbSpeedUpdate(stats: SpeedDisplayData) {
binding.stats.updateSpeed(stats.txRateProxy, stats.rxRateProxy)
}
override fun cbTrafficUpdate(data: TrafficData) {
runOnDefaultDispatcher {
ProfileManager.postUpdate(data)
}
}
override fun cbSelectorUpdate(id: Long) {
val old = DataStore.selectedProxy
DataStore.selectedProxy = id
DataStore.currentProfile = id
runOnDefaultDispatcher {
ProfileManager.postUpdate(old, true)
ProfileManager.postUpdate(id, true)
}
}
override fun onPreferenceDataStoreChanged(store: PreferenceDataStore, key: String) {
when (key) {
Key.SERVICE_MODE -> onBinderDied()
Key.PROXY_APPS, Key.BYPASS_MODE, Key.INDIVIDUAL -> {
if (DataStore.serviceState.canStop) {
snackbar(getString(R.string.need_reload)).setAction(R.string.apply) {
SagerNet.reloadService()
}.show()
}
}
}
}
override fun onStart() {
connection.updateConnectionId(SagerConnection.CONNECTION_ID_MAIN_ACTIVITY_FOREGROUND)
super.onStart()
}
override fun onStop() {
connection.updateConnectionId(SagerConnection.CONNECTION_ID_MAIN_ACTIVITY_BACKGROUND)
super.onStop()
}
override fun onDestroy() {
super.onDestroy()
GroupManager.userInterface = null
DataStore.configurationStore.unregisterChangeListener(this)
connection.disconnect(this)
}
override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
when (keyCode) {
KeyEvent.KEYCODE_DPAD_LEFT -> {
if (super.onKeyDown(keyCode, event)) return true
binding.drawerLayout.open()
navigation.requestFocus()
}
KeyEvent.KEYCODE_DPAD_RIGHT -> {
if (binding.drawerLayout.isOpen) {
binding.drawerLayout.close()
return true
}
}
}
if (super.onKeyDown(keyCode, event)) return true
if (binding.drawerLayout.isOpen) return false
val fragment =
supportFragmentManager.findFragmentById(R.id.fragment_holder) as? ToolbarFragment
return fragment != null && fragment.onKeyDown(keyCode, event)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/MainActivity.kt | 2164082405 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProfileManager
import io.nekohasekai.sagernet.ktx.runOnMainDispatcher
class SwitchActivity : ThemedActivity(R.layout.layout_empty),
ConfigurationFragment.SelectCallback {
override val isDialog = true
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
supportFragmentManager.beginTransaction()
.replace(
R.id.fragment_holder,
ConfigurationFragment(true, null, R.string.action_switch)
)
.commitAllowingStateLoss()
}
override fun returnProfile(profileId: Long) {
val old = DataStore.selectedProxy
DataStore.selectedProxy = profileId
runOnMainDispatcher {
ProfileManager.postUpdate(old, true)
ProfileManager.postUpdate(profileId, true)
}
SagerNet.reloadService()
finish()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/SwitchActivity.kt | 648582586 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import moe.matsuri.nb4a.utils.SendLog
class BlankActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// process crash log
intent?.getStringExtra("sendLog")?.apply {
SendLog.sendLog(this@BlankActivity, this)
}
finish()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/BlankActivity.kt | 2699665077 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.os.Bundle
import android.text.format.Formatter
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import android.widget.LinearLayout
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.widget.PopupMenu
import androidx.appcompat.widget.Toolbar
import androidx.core.view.*
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.GroupType
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.GroupManager
import io.nekohasekai.sagernet.database.ProxyGroup
import io.nekohasekai.sagernet.database.SagerDatabase
import io.nekohasekai.sagernet.databinding.LayoutGroupItemBinding
import io.nekohasekai.sagernet.fmt.toUniversalLink
import io.nekohasekai.sagernet.group.GroupUpdater
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.widget.ListHolderListener
import io.nekohasekai.sagernet.widget.QRCodeDialog
import io.nekohasekai.sagernet.widget.UndoSnackbarManager
import kotlinx.coroutines.delay
import moe.matsuri.nb4a.utils.Util
import moe.matsuri.nb4a.utils.toBytesString
import java.util.*
class GroupFragment : ToolbarFragment(R.layout.layout_group),
Toolbar.OnMenuItemClickListener {
lateinit var activity: MainActivity
lateinit var groupListView: RecyclerView
lateinit var layoutManager: LinearLayoutManager
lateinit var groupAdapter: GroupAdapter
lateinit var undoManager: UndoSnackbarManager<ProxyGroup>
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
activity = requireActivity() as MainActivity
ViewCompat.setOnApplyWindowInsetsListener(view, ListHolderListener)
toolbar.setTitle(R.string.menu_group)
toolbar.inflateMenu(R.menu.add_group_menu)
toolbar.setOnMenuItemClickListener(this)
groupListView = view.findViewById(R.id.group_list)
layoutManager = FixedLinearLayoutManager(groupListView)
groupListView.layoutManager = layoutManager
groupAdapter = GroupAdapter()
GroupManager.addListener(groupAdapter)
groupListView.adapter = groupAdapter
undoManager = UndoSnackbarManager(activity, groupAdapter)
ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(
ItemTouchHelper.UP or ItemTouchHelper.DOWN, ItemTouchHelper.START
) {
override fun getSwipeDirs(
recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder
): Int {
val proxyGroup = (viewHolder as GroupHolder).proxyGroup
if (proxyGroup.ungrouped || proxyGroup.id in GroupUpdater.updating) {
return 0
}
return super.getSwipeDirs(recyclerView, viewHolder)
}
override fun getDragDirs(
recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder
): Int {
val proxyGroup = (viewHolder as GroupHolder).proxyGroup
if (proxyGroup.ungrouped || proxyGroup.id in GroupUpdater.updating) {
return 0
}
return super.getDragDirs(recyclerView, viewHolder)
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
val index = viewHolder.bindingAdapterPosition
groupAdapter.remove(index)
undoManager.remove(index to (viewHolder as GroupHolder).proxyGroup)
}
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder, target: RecyclerView.ViewHolder,
): Boolean {
groupAdapter.move(viewHolder.bindingAdapterPosition, target.bindingAdapterPosition)
return true
}
override fun clearView(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) {
super.clearView(recyclerView, viewHolder)
groupAdapter.commitMove()
}
}).attachToRecyclerView(groupListView)
}
override fun onMenuItemClick(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_new_group -> {
startActivity(Intent(context, GroupSettingsActivity::class.java))
}
R.id.action_update_all -> {
MaterialAlertDialogBuilder(requireContext()).setTitle(R.string.confirm)
.setMessage(R.string.update_all_subscription)
.setPositiveButton(R.string.yes) { _, _ ->
SagerDatabase.groupDao.allGroups()
.filter { it.type == GroupType.SUBSCRIPTION }
.forEach {
GroupUpdater.startUpdate(it, true)
}
}
.setNegativeButton(R.string.no, null)
.show()
}
}
return true
}
private lateinit var selectedGroup: ProxyGroup
private val exportProfiles =
registerForActivityResult(ActivityResultContracts.CreateDocument()) { data ->
if (data != null) {
runOnDefaultDispatcher {
val profiles = SagerDatabase.proxyDao.getByGroup(selectedGroup.id)
val links = profiles.joinToString("\n") { it.toStdLink(compact = true) }
try {
(requireActivity() as MainActivity).contentResolver.openOutputStream(
data
)!!.bufferedWriter().use {
it.write(links)
}
onMainDispatcher {
snackbar(getString(R.string.action_export_msg)).show()
}
} catch (e: Exception) {
Logs.w(e)
onMainDispatcher {
snackbar(e.readableMessage).show()
}
}
}
}
}
inner class GroupAdapter : RecyclerView.Adapter<GroupHolder>(),
GroupManager.Listener,
UndoSnackbarManager.Interface<ProxyGroup> {
val groupList = ArrayList<ProxyGroup>()
suspend fun reload() {
val groups = SagerDatabase.groupDao.allGroups().toMutableList()
if (groups.size > 1 && SagerDatabase.proxyDao.countByGroup(groups.find { it.ungrouped }!!.id) == 0L) groups.removeAll { it.ungrouped }
groupList.clear()
groupList.addAll(groups)
groupListView.post {
notifyDataSetChanged()
}
}
init {
setHasStableIds(true)
runOnDefaultDispatcher {
reload()
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): GroupHolder {
return GroupHolder(LayoutGroupItemBinding.inflate(layoutInflater, parent, false))
}
override fun onBindViewHolder(holder: GroupHolder, position: Int) {
holder.bind(groupList[position])
}
override fun getItemCount(): Int {
return groupList.size
}
override fun getItemId(position: Int): Long {
return groupList[position].id
}
private val updated = HashSet<ProxyGroup>()
fun move(from: Int, to: Int) {
val first = groupList[from]
var previousOrder = first.userOrder
val (step, range) = if (from < to) Pair(1, from until to) else Pair(
-1, to + 1 downTo from
)
for (i in range) {
val next = groupList[i + step]
val order = next.userOrder
next.userOrder = previousOrder
previousOrder = order
groupList[i] = next
updated.add(next)
}
first.userOrder = previousOrder
groupList[to] = first
updated.add(first)
notifyItemMoved(from, to)
}
fun commitMove() = runOnDefaultDispatcher {
updated.forEach { SagerDatabase.groupDao.updateGroup(it) }
updated.clear()
}
fun remove(index: Int) {
groupList.removeAt(index)
notifyItemRemoved(index)
}
override fun undo(actions: List<Pair<Int, ProxyGroup>>) {
for ((index, item) in actions) {
groupList.add(index, item)
notifyItemInserted(index)
}
}
override fun commit(actions: List<Pair<Int, ProxyGroup>>) {
val groups = actions.map { it.second }
runOnDefaultDispatcher {
GroupManager.deleteGroup(groups)
reload()
}
}
override suspend fun groupAdd(group: ProxyGroup) {
groupList.add(group)
delay(300L)
onMainDispatcher {
undoManager.flush()
notifyItemInserted(groupList.size - 1)
if (group.type == GroupType.SUBSCRIPTION) {
GroupUpdater.startUpdate(group, true)
}
}
}
override suspend fun groupRemoved(groupId: Long) {
val index = groupList.indexOfFirst { it.id == groupId }
if (index == -1) return
onMainDispatcher {
undoManager.flush()
if (SagerDatabase.groupDao.allGroups().size <= 2) {
runOnDefaultDispatcher {
reload()
}
} else {
groupList.removeAt(index)
notifyItemRemoved(index)
}
}
}
override suspend fun groupUpdated(group: ProxyGroup) {
val index = groupList.indexOfFirst { it.id == group.id }
if (index == -1) {
reload()
return
}
groupList[index] = group
onMainDispatcher {
undoManager.flush()
notifyItemChanged(index)
}
}
override suspend fun groupUpdated(groupId: Long) {
val index = groupList.indexOfFirst { it.id == groupId }
if (index == -1) {
reload()
return
}
onMainDispatcher {
notifyItemChanged(index)
}
}
}
override fun onDestroy() {
if (::groupAdapter.isInitialized) {
GroupManager.removeListener(groupAdapter)
}
super.onDestroy()
if (!::undoManager.isInitialized) return
undoManager.flush()
}
inner class GroupHolder(binding: LayoutGroupItemBinding) :
RecyclerView.ViewHolder(binding.root),
PopupMenu.OnMenuItemClickListener {
lateinit var proxyGroup: ProxyGroup
val groupName = binding.groupName
val groupStatus = binding.groupStatus
val groupTraffic = binding.groupTraffic
val groupUser = binding.groupUser
val editButton = binding.edit
val optionsButton = binding.options
val updateButton = binding.groupUpdate
val subscriptionUpdateProgress = binding.subscriptionUpdateProgress
override fun onMenuItemClick(item: MenuItem): Boolean {
fun export(link: String) {
val success = SagerNet.trySetPrimaryClip(link)
activity.snackbar(if (success) R.string.action_export_msg else R.string.action_export_err)
.show()
}
when (item.itemId) {
R.id.action_universal_qr -> {
QRCodeDialog(
proxyGroup.toUniversalLink(), proxyGroup.displayName()
).showAllowingStateLoss(parentFragmentManager)
}
R.id.action_universal_clipboard -> {
export(proxyGroup.toUniversalLink())
}
R.id.action_export_clipboard -> {
runOnDefaultDispatcher {
val profiles = SagerDatabase.proxyDao.getByGroup(selectedGroup.id)
val links = profiles.joinToString("\n") { it.toStdLink(compact = true) }
onMainDispatcher {
SagerNet.trySetPrimaryClip(links)
snackbar(getString(R.string.copy_toast_msg)).show()
}
}
}
R.id.action_export_file -> {
startFilesForResult(exportProfiles, "profiles_${proxyGroup.displayName()}.txt")
}
R.id.action_clear -> {
MaterialAlertDialogBuilder(requireContext()).setTitle(R.string.confirm)
.setMessage(R.string.clear_profiles_message)
.setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
GroupManager.clearGroup(proxyGroup.id)
}
}
.setNegativeButton(android.R.string.cancel, null)
.show()
}
}
return true
}
fun bind(group: ProxyGroup) {
proxyGroup = group
itemView.setOnClickListener { }
editButton.isGone = proxyGroup.ungrouped
updateButton.isInvisible = proxyGroup.type != GroupType.SUBSCRIPTION
groupName.text = proxyGroup.displayName()
editButton.setOnClickListener {
startActivity(Intent(it.context, GroupSettingsActivity::class.java).apply {
putExtra(GroupSettingsActivity.EXTRA_GROUP_ID, group.id)
})
}
updateButton.setOnClickListener {
GroupUpdater.startUpdate(proxyGroup, true)
}
optionsButton.setOnClickListener {
selectedGroup = proxyGroup
val popup = PopupMenu(requireContext(), it)
popup.menuInflater.inflate(R.menu.group_action_menu, popup.menu)
if (proxyGroup.type != GroupType.SUBSCRIPTION) {
popup.menu.removeItem(R.id.action_share_subscription)
}
popup.setOnMenuItemClickListener(this)
popup.show()
}
if (proxyGroup.id in GroupUpdater.updating) {
(groupName.parent as LinearLayout).apply {
setPadding(paddingLeft, dp2px(11), paddingRight, paddingBottom)
}
subscriptionUpdateProgress.isVisible = true
if (!GroupUpdater.progress.containsKey(proxyGroup.id)) {
subscriptionUpdateProgress.isIndeterminate = true
} else {
subscriptionUpdateProgress.isIndeterminate = false
GroupUpdater.progress[proxyGroup.id]?.let {
subscriptionUpdateProgress.max = it.max
subscriptionUpdateProgress.progress = it.progress
}
}
updateButton.isInvisible = true
editButton.isGone = true
} else {
(groupName.parent as LinearLayout).apply {
setPadding(paddingLeft, dp2px(15), paddingRight, paddingBottom)
}
subscriptionUpdateProgress.isVisible = false
updateButton.isInvisible = proxyGroup.type != GroupType.SUBSCRIPTION
editButton.isGone = proxyGroup.ungrouped
}
val subscription = proxyGroup.subscription
if (subscription != null && subscription.bytesUsed > 0L) { // SIP008 & Open Online Config
groupTraffic.isVisible = true
groupTraffic.text = if (subscription.bytesRemaining > 0L) {
app.getString(
R.string.subscription_traffic, Formatter.formatFileSize(
app, subscription.bytesUsed
), Formatter.formatFileSize(
app, subscription.bytesRemaining
)
)
} else {
app.getString(
R.string.subscription_used, Formatter.formatFileSize(
app, subscription.bytesUsed
)
)
}
groupStatus.setPadding(0)
} else if (subscription != null && !subscription.subscriptionUserinfo.isNullOrBlank()) { // Raw
var text = ""
fun get(regex: String): String? {
return regex.toRegex().findAll(subscription.subscriptionUserinfo).mapNotNull {
if (it.groupValues.size > 1) it.groupValues[1] else null
}.firstOrNull()
}
try {
var used: Long = 0
get("upload=([0-9]+)")?.apply {
used += toLong()
}
get("download=([0-9]+)")?.apply {
used += toLong()
}
val total = get("total=([0-9]+)")?.toLong() ?: 0
if (used > 0 || total > 0) {
text += getString(
R.string.subscription_traffic,
used.toBytesString(),
(total - used).toBytesString()
)
}
get("expire=([0-9]+)")?.apply {
text += "\n"
text += getString(
R.string.subscription_expire,
Util.timeStamp2Text(this.toLong() * 1000)
)
}
} catch (_: NumberFormatException) {
// ignore
}
if (text.isNotEmpty()) {
groupTraffic.isVisible = true
groupTraffic.text = text
groupStatus.setPadding(0)
}
} else {
groupTraffic.isVisible = false
groupStatus.setPadding(0, 0, 0, dp2px(4))
}
groupUser.text = subscription?.username ?: ""
runOnDefaultDispatcher {
val size = SagerDatabase.proxyDao.countByGroup(group.id)
onMainDispatcher {
@Suppress("DEPRECATION") when (group.type) {
GroupType.BASIC -> {
if (size == 0L) {
groupStatus.setText(R.string.group_status_empty)
} else {
groupStatus.text = getString(R.string.group_status_proxies, size)
}
}
GroupType.SUBSCRIPTION -> {
groupStatus.text = if (size == 0L) {
getString(R.string.group_status_empty_subscription)
} else {
val date = Date(group.subscription!!.lastUpdated * 1000L)
getString(
R.string.group_status_proxies_subscription,
size,
"${date.month + 1} - ${date.date}"
)
}
}
}
}
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/GroupFragment.kt | 2820462486 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.content.pm.ApplicationInfo
import android.content.pm.PackageInfo
import android.content.pm.PackageManager
import android.graphics.drawable.Drawable
import android.os.Bundle
import android.util.SparseBooleanArray
import android.view.*
import android.widget.Filter
import android.widget.Filterable
import androidx.annotation.UiThread
import androidx.core.util.contains
import androidx.core.util.set
import androidx.core.view.ViewCompat
import androidx.core.view.isGone
import androidx.core.view.isVisible
import androidx.core.widget.addTextChangedListener
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.DefaultItemAnimator
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.snackbar.Snackbar
import com.simplecityapps.recyclerview_fastscroll.views.FastScrollRecyclerView
import io.nekohasekai.sagernet.BuildConfig
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.databinding.LayoutAppListBinding
import io.nekohasekai.sagernet.databinding.LayoutAppsItemBinding
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.utils.PackageCache
import io.nekohasekai.sagernet.widget.ListHolderListener
import io.nekohasekai.sagernet.widget.ListListener
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.withContext
import moe.matsuri.nb4a.plugin.NekoPluginManager
import moe.matsuri.nb4a.plugin.Plugins
import moe.matsuri.nb4a.proxy.neko.NekoJSInterface
import moe.matsuri.nb4a.ui.Dialogs
import kotlin.coroutines.coroutineContext
class AppListActivity : ThemedActivity() {
companion object {
private const val SWITCH = "switch"
}
private class ProxiedApp(
private val pm: PackageManager, private val appInfo: ApplicationInfo,
val packageName: String,
) {
val name: CharSequence = appInfo.loadLabel(pm) // cached for sorting
val icon: Drawable get() = appInfo.loadIcon(pm)
val uid get() = appInfo.uid
val sys get() = (appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0
}
private inner class AppViewHolder(val binding: LayoutAppsItemBinding) : RecyclerView.ViewHolder(
binding.root
),
View.OnClickListener {
private lateinit var item: ProxiedApp
init {
binding.root.setOnClickListener(this)
}
fun bind(app: ProxiedApp) {
item = app
binding.itemicon.setImageDrawable(app.icon)
binding.title.text = app.name
if (forNeko) {
val packageName = app.packageName
val ver = getCachedApps()[packageName]?.versionName ?: ""
binding.desc.text = "$packageName ($ver)"
//
binding.button.isVisible = true
binding.button.setImageDrawable(getDrawable(R.drawable.ic_baseline_info_24))
binding.button.setOnClickListener {
runOnIoDispatcher {
val jsi = NekoJSInterface(packageName)
jsi.init()
val about = jsi.getAbout()
jsi.destorySuspend()
Dialogs.message(
this@AppListActivity, app.name as String,
"PackageName: ${packageName}\n" +
"Version: ${ver}\n" +
"--------\n" + about
)
}
}
} else {
binding.desc.text = "${app.packageName} (${app.uid})"
}
handlePayload(listOf(SWITCH))
}
fun handlePayload(payloads: List<String>) {
if (payloads.contains(SWITCH)) {
val selected = isProxiedApp(item)
binding.itemcheck.isChecked = selected
binding.button.isVisible = forNeko && selected
}
}
override fun onClick(v: View?) {
if (isProxiedApp(item)) proxiedUids.delete(item.uid) else proxiedUids[item.uid] = true
DataStore.routePackages = apps.filter { isProxiedApp(it) }
.joinToString("\n") { it.packageName }
if (forNeko) {
if (isProxiedApp(item)) {
runOnIoDispatcher {
try {
NekoPluginManager.installPlugin(item.packageName)
} catch (e: Exception) {
// failed UI
runOnUiThread { onClick(v) }
Dialogs.logExceptionAndShow(this@AppListActivity, e) { }
}
}
} else {
NekoPluginManager.removeManagedPlugin(item.packageName)
}
}
appsAdapter.notifyItemRangeChanged(0, appsAdapter.itemCount, SWITCH)
}
}
private inner class AppsAdapter : RecyclerView.Adapter<AppViewHolder>(),
Filterable,
FastScrollRecyclerView.SectionedAdapter {
var filteredApps = apps
suspend fun reload() {
apps = getCachedApps().map { (packageName, packageInfo) ->
coroutineContext[Job]!!.ensureActive()
ProxiedApp(packageManager, packageInfo.applicationInfo, packageName)
}.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
}
override fun onBindViewHolder(holder: AppViewHolder, position: Int) =
holder.bind(filteredApps[position])
override fun onBindViewHolder(holder: AppViewHolder, position: Int, payloads: List<Any>) {
if (payloads.isNotEmpty()) {
@Suppress("UNCHECKED_CAST") holder.handlePayload(payloads as List<String>)
return
}
onBindViewHolder(holder, position)
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AppViewHolder =
AppViewHolder(LayoutAppsItemBinding.inflate(layoutInflater, parent, false))
override fun getItemCount(): Int = filteredApps.size
private val filterImpl = object : Filter() {
override fun performFiltering(constraint: CharSequence) = FilterResults().apply {
var filteredApps = if (constraint.isEmpty()) apps else apps.filter {
it.name.contains(constraint, true) || it.packageName.contains(
constraint, true
) || it.uid.toString().contains(constraint)
}
if (!sysApps) filteredApps = filteredApps.filter { !it.sys }
count = filteredApps.size
values = filteredApps
}
override fun publishResults(constraint: CharSequence, results: FilterResults) {
@Suppress("UNCHECKED_CAST")
filteredApps = results.values as List<ProxiedApp>
notifyDataSetChanged()
}
}
override fun getFilter(): Filter = filterImpl
override fun getSectionName(position: Int): String {
return filteredApps[position].name.firstOrNull()?.toString() ?: ""
}
}
private val loading by lazy { findViewById<View>(R.id.loading) }
private lateinit var binding: LayoutAppListBinding
private val proxiedUids = SparseBooleanArray()
private var loader: Job? = null
private var apps = emptyList<ProxiedApp>()
private val appsAdapter = AppsAdapter()
private fun initProxiedUids(str: String = DataStore.routePackages) {
proxiedUids.clear()
val apps = getCachedApps()
for (line in str.lineSequence()) proxiedUids[(apps[line]
?: continue).applicationInfo.uid] = true
}
private fun isProxiedApp(app: ProxiedApp) = proxiedUids[app.uid]
@UiThread
private fun loadApps() {
loader?.cancel()
loader = lifecycleScope.launchWhenCreated {
loading.crossFadeFrom(binding.list)
val adapter = binding.list.adapter as AppsAdapter
withContext(Dispatchers.IO) { adapter.reload() }
adapter.filter.filter(binding.search.text?.toString() ?: "")
binding.list.crossFadeFrom(loading)
}
}
private var forNeko = false
fun getCachedApps(): MutableMap<String, PackageInfo> {
val packages =
if (forNeko) PackageCache.installedPluginPackages else PackageCache.installedPackages
return packages.toMutableMap().apply {
remove(BuildConfig.APPLICATION_ID)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
forNeko = intent?.hasExtra(Key.NEKO_PLUGIN_MANAGED) == true
binding = LayoutAppListBinding.inflate(layoutInflater)
setContentView(binding.root)
ListHolderListener.setup(this)
setSupportActionBar(binding.toolbar)
supportActionBar?.apply {
setTitle(R.string.select_apps)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
initProxiedUids()
binding.list.layoutManager = LinearLayoutManager(this, RecyclerView.VERTICAL, false)
binding.list.itemAnimator = DefaultItemAnimator()
binding.list.adapter = appsAdapter
ViewCompat.setOnApplyWindowInsetsListener(binding.root, ListListener)
binding.search.addTextChangedListener {
appsAdapter.filter.filter(it?.toString() ?: "")
}
binding.showSystemApps.isChecked = sysApps
binding.showSystemApps.setOnCheckedChangeListener { _, isChecked ->
sysApps = isChecked
appsAdapter.filter.filter(binding.search.text?.toString() ?: "")
}
if (forNeko) {
DataStore.routePackages = DataStore.nekoPlugins
binding.search.setText(Plugins.AUTHORITIES_PREFIX_NEKO_PLUGIN)
}
binding.searchLayout.isGone = forNeko
binding.hintNekoPlugin.isGone = !forNeko
binding.actionLearnMore.setOnClickListener {
launchCustomTab("https://AntiNeko.github.io/m-plugin/")
}
loadApps()
}
private var sysApps = false
override fun onCreateOptionsMenu(menu: Menu): Boolean {
if (forNeko) {
menuInflater.inflate(R.menu.app_list_neko_menu, menu)
} else {
menuInflater.inflate(R.menu.app_list_menu, menu)
}
return true
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_invert_selections -> {
runOnDefaultDispatcher {
for (app in apps) {
if (proxiedUids.contains(app.uid)) {
proxiedUids.delete(app.uid)
} else {
proxiedUids[app.uid] = true
}
}
DataStore.routePackages = apps.filter { isProxiedApp(it) }
.joinToString("\n") { it.packageName }
apps = apps.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
onMainDispatcher {
appsAdapter.filter.filter(binding.search.text?.toString() ?: "")
}
}
return true
}
R.id.action_clear_selections -> {
runOnDefaultDispatcher {
proxiedUids.clear()
DataStore.routePackages = ""
apps = apps.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
onMainDispatcher {
appsAdapter.filter.filter(binding.search.text?.toString() ?: "")
}
}
}
R.id.action_export_clipboard -> {
val success = SagerNet.trySetPrimaryClip("false\n${DataStore.routePackages}")
Snackbar.make(
binding.list,
if (success) R.string.action_export_msg else R.string.action_export_err,
Snackbar.LENGTH_LONG
).show()
return true
}
R.id.action_import_clipboard -> {
val proxiedAppString =
SagerNet.clipboard.primaryClip?.getItemAt(0)?.text?.toString()
if (!proxiedAppString.isNullOrEmpty()) {
val i = proxiedAppString.indexOf('\n')
try {
val apps = if (i < 0) "" else proxiedAppString.substring(i + 1)
DataStore.routePackages = apps
Snackbar.make(
binding.list, R.string.action_import_msg, Snackbar.LENGTH_LONG
).show()
initProxiedUids(apps)
appsAdapter.notifyItemRangeChanged(0, appsAdapter.itemCount, SWITCH)
return true
} catch (_: IllegalArgumentException) {
}
}
Snackbar.make(binding.list, R.string.action_import_err, Snackbar.LENGTH_LONG).show()
}
R.id.uninstall_all -> {
runOnDefaultDispatcher {
proxiedUids.clear()
DataStore.routePackages = ""
apps = apps.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
NekoPluginManager.plugins.forEach {
NekoPluginManager.removeManagedPlugin(it)
}
onMainDispatcher {
appsAdapter.notifyItemRangeChanged(0, appsAdapter.itemCount, SWITCH)
}
}
}
}
return super.onOptionsItemSelected(item)
}
override fun onSupportNavigateUp(): Boolean {
if (!super.onSupportNavigateUp()) finish()
return true
}
override fun supportNavigateUpTo(upIntent: Intent) =
super.supportNavigateUpTo(upIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP))
override fun onKeyUp(keyCode: Int, event: KeyEvent?) = if (keyCode == KeyEvent.KEYCODE_MENU) {
if (binding.toolbar.isOverflowMenuShowing) binding.toolbar.hideOverflowMenu() else binding.toolbar.showOverflowMenu()
} else super.onKeyUp(keyCode, event)
override fun onDestroy() {
loader?.cancel()
if (forNeko) DataStore.nekoPlugins = DataStore.routePackages
super.onDestroy()
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/AppListActivity.kt | 3044536230 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.os.Bundle
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.ProxyEntity
class ProfileSelectActivity : ThemedActivity(R.layout.layout_empty),
ConfigurationFragment.SelectCallback {
companion object {
const val EXTRA_SELECTED = "selected"
const val EXTRA_PROFILE_ID = "id"
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val selected = intent.getParcelableExtra<ProxyEntity>(EXTRA_SELECTED)
supportFragmentManager.beginTransaction()
.replace(
R.id.fragment_holder,
ConfigurationFragment(true, selected, R.string.select_profile)
)
.commitAllowingStateLoss()
}
override fun returnProfile(profileId: Long) {
setResult(RESULT_OK, Intent().apply {
putExtra(EXTRA_PROFILE_ID, profileId)
})
finish()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/ProfileSelectActivity.kt | 3207461617 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import android.view.View
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.databinding.LayoutDebugBinding
import io.nekohasekai.sagernet.ktx.snackbar
class DebugFragment : NamedFragment(R.layout.layout_debug) {
override fun name0() = "Debug"
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val binding = LayoutDebugBinding.bind(view)
binding.debugCrash.setOnClickListener {
error("test crash")
}
binding.resetSettings.setOnClickListener {
DataStore.configurationStore.reset()
snackbar("Cleared").show()
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/DebugFragment.kt | 735129193 |
package io.nekohasekai.sagernet.ui
import android.Manifest
import android.content.Intent
import android.content.pm.ShortcutManager
import android.graphics.ImageDecoder
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.provider.MediaStore
import android.view.Menu
import android.view.MenuItem
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.content.getSystemService
import com.google.zxing.Result
import com.king.zxing.CameraScan
import com.king.zxing.DefaultCameraScan
import com.king.zxing.analyze.QRCodeAnalyzer
import com.king.zxing.util.CodeUtils
import com.king.zxing.util.LogUtils
import com.king.zxing.util.PermissionUtils
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProfileManager
import io.nekohasekai.sagernet.databinding.LayoutScannerBinding
import io.nekohasekai.sagernet.group.RawUpdater
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.widget.ListHolderListener
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
class ScannerActivity : ThemedActivity(),
CameraScan.OnScanResultCallback {
lateinit var binding: LayoutScannerBinding
lateinit var cameraScan: CameraScan
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
if (Build.VERSION.SDK_INT >= 25) getSystemService<ShortcutManager>()!!.reportShortcutUsed("scan")
binding = LayoutScannerBinding.inflate(layoutInflater)
setContentView(binding.root)
ListHolderListener.setup(this)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
// 二维码库
initCameraScan()
startCamera()
binding.ivFlashlight.setOnClickListener { toggleTorchState() }
}
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.scanner_menu, menu)
return true
}
val importCodeFile = registerForActivityResult(ActivityResultContracts.GetMultipleContents()) {
runOnDefaultDispatcher {
try {
it.forEachTry { uri ->
val bitmap = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
ImageDecoder.decodeBitmap(
ImageDecoder.createSource(
contentResolver, uri
)
) { decoder, _, _ ->
decoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
decoder.isMutableRequired = true
}
} else {
@Suppress("DEPRECATION") MediaStore.Images.Media.getBitmap(
contentResolver, uri
)
}
val result = CodeUtils.parseCodeResult(bitmap)
onMainDispatcher {
onScanResultCallback(result, true)
}
}
finish()
} catch (e: Exception) {
Logs.w(e)
onMainDispatcher {
Toast.makeText(app, e.readableMessage, Toast.LENGTH_LONG).show()
}
}
}
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
return if (item.itemId == R.id.action_import_file) {
startFilesForResult(importCodeFile, "image/*")
true
} else {
super.onOptionsItemSelected(item)
}
}
var finished = AtomicBoolean(false)
var importedN = AtomicInteger(0)
/**
* 接收扫码结果回调
* @param result 扫码结果
* @return 返回true表示拦截，将不自动执行后续逻辑，为false表示不拦截，默认不拦截
*/
override fun onScanResultCallback(result: Result?): Boolean {
return onScanResultCallback(result, false)
}
fun onScanResultCallback(result: Result?, multi: Boolean): Boolean {
if (!multi && finished.getAndSet(true)) return true
if (!multi) finish()
runOnDefaultDispatcher {
try {
val text = result?.text ?: throw Exception("QR code not found")
val results = RawUpdater.parseRaw(text)
if (!results.isNullOrEmpty()) {
val currentGroupId = DataStore.selectedGroupForImport()
if (DataStore.selectedGroup != currentGroupId) {
DataStore.selectedGroup = currentGroupId
}
for (profile in results) {
ProfileManager.createProfile(currentGroupId, profile)
importedN.addAndGet(1)
}
} else {
onMainDispatcher {
Toast.makeText(app, R.string.action_import_err, Toast.LENGTH_SHORT).show()
}
}
} catch (e: SubscriptionFoundException) {
startActivity(Intent(this@ScannerActivity, MainActivity::class.java).apply {
action = Intent.ACTION_VIEW
data = Uri.parse(e.link)
})
} catch (e: Throwable) {
Logs.w(e)
onMainDispatcher {
var text = getString(R.string.action_import_err)
text += "\n" + e.readableMessage
Toast.makeText(app, text, Toast.LENGTH_SHORT).show()
}
}
}
return true
}
/**
* 初始化CameraScan
*/
fun initCameraScan() {
cameraScan = DefaultCameraScan(this, binding.previewView)
cameraScan.setAnalyzer(QRCodeAnalyzer())
cameraScan.setOnScanResultCallback(this)
cameraScan.setNeedAutoZoom(true)
}
/**
* 启动相机预览
*/
fun startCamera() {
if (PermissionUtils.checkPermission(this, Manifest.permission.CAMERA)) {
cameraScan.startCamera()
} else {
LogUtils.d("checkPermissionResult != PERMISSION_GRANTED")
PermissionUtils.requestPermission(
this, Manifest.permission.CAMERA, CAMERA_PERMISSION_REQUEST_CODE
)
}
}
/**
* 释放相机
*/
private fun releaseCamera() {
cameraScan.release()
}
/**
* 切换闪光灯状态（开启/关闭）
*/
protected fun toggleTorchState() {
val isTorch = cameraScan.isTorchEnabled
cameraScan.enableTorch(!isTorch)
binding.ivFlashlight.isSelected = !isTorch
}
val CAMERA_PERMISSION_REQUEST_CODE = 0X86
override fun onRequestPermissionsResult(
requestCode: Int, permissions: Array<String>, grantResults: IntArray
) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
if (requestCode == CAMERA_PERMISSION_REQUEST_CODE) {
requestCameraPermissionResult(permissions, grantResults)
}
}
/**
* 请求Camera权限回调结果
* @param permissions
* @param grantResults
*/
fun requestCameraPermissionResult(permissions: Array<String>, grantResults: IntArray) {
if (PermissionUtils.requestPermissionsResult(
Manifest.permission.CAMERA, permissions, grantResults
)
) {
startCamera()
} else {
finish()
}
}
override fun onDestroy() {
releaseCamera()
super.onDestroy()
if (importedN.get() > 0) {
var text = getString(R.string.action_import_msg)
text += "\n" + importedN.get() + " profile(s)"
Toast.makeText(app, text, Toast.LENGTH_LONG).show()
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/ScannerActivity.kt | 475087028 |
package io.nekohasekai.sagernet.ui
import android.annotation.SuppressLint
import android.app.Activity
import android.content.DialogInterface
import android.content.Intent
import android.os.Bundle
import android.os.Parcelable
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.annotation.LayoutRes
import androidx.appcompat.app.AlertDialog
import androidx.core.view.ViewCompat
import androidx.preference.*
import com.github.shadowsocks.plugin.Empty
import com.github.shadowsocks.plugin.fragment.AlertDialogFragment
import io.nekohasekai.sagernet.GroupType
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.*
import io.nekohasekai.sagernet.database.preference.OnPreferenceDataStoreChangeListener
import io.nekohasekai.sagernet.ktx.Logs
import io.nekohasekai.sagernet.ktx.applyDefaultValues
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.runOnDefaultDispatcher
import io.nekohasekai.sagernet.widget.ListListener
import io.nekohasekai.sagernet.widget.OutboundPreference
import kotlinx.parcelize.Parcelize
import moe.matsuri.nb4a.ui.SimpleMenuPreference
@Suppress("UNCHECKED_CAST")
class GroupSettingsActivity(
@LayoutRes resId: Int = R.layout.layout_config_settings,
) : ThemedActivity(resId),
OnPreferenceDataStoreChangeListener {
private lateinit var frontProxyPreference: OutboundPreference
private lateinit var landingProxyPreference: OutboundPreference
fun ProxyGroup.init() {
DataStore.groupName = name ?: ""
DataStore.groupType = type
DataStore.groupOrder = order
DataStore.groupIsSelector = isSelector
DataStore.frontProxy = frontProxy
DataStore.landingProxy = landingProxy
DataStore.frontProxyTmp = if (frontProxy >= 0) 3 else 0
DataStore.landingProxyTmp = if (landingProxy >= 0) 3 else 0
val subscription = subscription ?: SubscriptionBean().applyDefaultValues()
DataStore.subscriptionLink = subscription.link
DataStore.subscriptionForceResolve = subscription.forceResolve
DataStore.subscriptionDeduplication = subscription.deduplication
DataStore.subscriptionUpdateWhenConnectedOnly = subscription.updateWhenConnectedOnly
DataStore.subscriptionUserAgent = subscription.customUserAgent
DataStore.subscriptionAutoUpdate = subscription.autoUpdate
DataStore.subscriptionAutoUpdateDelay = subscription.autoUpdateDelay
}
fun ProxyGroup.serialize() {
name = DataStore.groupName.takeIf { it.isNotBlank() } ?: "My group"
type = DataStore.groupType
order = DataStore.groupOrder
isSelector = DataStore.groupIsSelector
frontProxy = if (DataStore.frontProxyTmp == 3) DataStore.frontProxy else -1
landingProxy = if (DataStore.landingProxyTmp == 3) DataStore.landingProxy else -1
val isSubscription = type == GroupType.SUBSCRIPTION
if (isSubscription) {
subscription = (subscription ?: SubscriptionBean().applyDefaultValues()).apply {
link = DataStore.subscriptionLink
forceResolve = DataStore.subscriptionForceResolve
deduplication = DataStore.subscriptionDeduplication
updateWhenConnectedOnly = DataStore.subscriptionUpdateWhenConnectedOnly
customUserAgent = DataStore.subscriptionUserAgent
autoUpdate = DataStore.subscriptionAutoUpdate
autoUpdateDelay = DataStore.subscriptionAutoUpdateDelay
}
}
}
fun needSave(): Boolean {
if (!DataStore.dirty) return false
return true
}
fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.group_preferences)
frontProxyPreference = findPreference(Key.GROUP_FRONT_PROXY)!!
frontProxyPreference.apply {
setEntries(R.array.front_proxy_entry)
setEntryValues(R.array.front_proxy_value)
setOnPreferenceChangeListener { _, newValue ->
if (newValue.toString() == "3") {
selectProfileForAddFront.launch(
Intent(this@GroupSettingsActivity, ProfileSelectActivity::class.java)
)
false
} else {
true
}
}
}
landingProxyPreference = findPreference(Key.GROUP_LANDING_PROXY)!!
landingProxyPreference.apply {
setEntries(R.array.front_proxy_entry)
setEntryValues(R.array.front_proxy_value)
setOnPreferenceChangeListener { _, newValue ->
if (newValue.toString() == "3") {
selectProfileForAddLanding.launch(
Intent(this@GroupSettingsActivity, ProfileSelectActivity::class.java)
)
false
} else {
true
}
}
}
val groupType = findPreference<SimpleMenuPreference>(Key.GROUP_TYPE)!!
val groupSubscription = findPreference<PreferenceCategory>(Key.GROUP_SUBSCRIPTION)!!
val subscriptionUpdate = findPreference<PreferenceCategory>(Key.SUBSCRIPTION_UPDATE)!!
fun updateGroupType(groupType: Int = DataStore.groupType) {
val isSubscription = groupType == GroupType.SUBSCRIPTION
groupSubscription.isVisible = isSubscription
subscriptionUpdate.isVisible = isSubscription
}
updateGroupType()
groupType.setOnPreferenceChangeListener { _, newValue ->
updateGroupType((newValue as String).toInt())
true
}
val subscriptionAutoUpdate =
findPreference<SwitchPreference>(Key.SUBSCRIPTION_AUTO_UPDATE)!!
val subscriptionAutoUpdateDelay =
findPreference<EditTextPreference>(Key.SUBSCRIPTION_AUTO_UPDATE_DELAY)!!
subscriptionAutoUpdateDelay.isEnabled = subscriptionAutoUpdate.isChecked
subscriptionAutoUpdateDelay.setOnPreferenceChangeListener { _, newValue ->
val delay = (newValue as String).toIntOrNull()
if (delay == null) {
false
} else {
delay >= 15
}
}
subscriptionAutoUpdate.setOnPreferenceChangeListener { _, newValue ->
subscriptionAutoUpdateDelay.isEnabled = (newValue as Boolean)
true
}
}
class UnsavedChangesDialogFragment : AlertDialogFragment<Empty, Empty>() {
override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
setTitle(R.string.unsaved_changes_prompt)
setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
(requireActivity() as GroupSettingsActivity).saveAndExit()
}
}
setNegativeButton(R.string.no) { _, _ ->
requireActivity().finish()
}
setNeutralButton(android.R.string.cancel, null)
}
}
@Parcelize
data class GroupIdArg(val groupId: Long) : Parcelable
class DeleteConfirmationDialogFragment : AlertDialogFragment<GroupIdArg, Empty>() {
override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
setTitle(R.string.delete_group_prompt)
setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
GroupManager.deleteGroup(arg.groupId)
}
requireActivity().finish()
}
setNegativeButton(R.string.no, null)
}
}
companion object {
const val EXTRA_GROUP_ID = "id"
}
@SuppressLint("CommitTransaction")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setTitle(R.string.group_settings)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
if (savedInstanceState == null) {
val editingId = intent.getLongExtra(EXTRA_GROUP_ID, 0L)
DataStore.editingId = editingId
runOnDefaultDispatcher {
if (editingId == 0L) {
ProxyGroup().init()
} else {
val entity = SagerDatabase.groupDao.getById(editingId)
if (entity == null) {
onMainDispatcher {
finish()
}
return@runOnDefaultDispatcher
}
entity.init()
}
onMainDispatcher {
supportFragmentManager.beginTransaction()
.replace(R.id.settings, MyPreferenceFragmentCompat())
.commit()
DataStore.dirty = false
DataStore.profileCacheStore.registerChangeListener(this@GroupSettingsActivity)
}
}
}
}
suspend fun saveAndExit() {
val editingId = DataStore.editingId
if (editingId == 0L) {
GroupManager.createGroup(ProxyGroup().apply { serialize() })
} else if (needSave()) {
val entity = SagerDatabase.groupDao.getById(DataStore.editingId)
if (entity == null) {
finish()
return
}
val keepUserInfo = (entity.type == GroupType.SUBSCRIPTION &&
DataStore.groupType == GroupType.SUBSCRIPTION &&
entity.subscription?.link == DataStore.subscriptionLink)
if (!keepUserInfo) {
entity.subscription?.subscriptionUserinfo = "";
}
GroupManager.updateGroup(entity.apply { serialize() })
}
finish()
}
val child by lazy { supportFragmentManager.findFragmentById(R.id.settings) as MyPreferenceFragmentCompat }
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.profile_config_menu, menu)
return true
}
override fun onOptionsItemSelected(item: MenuItem) = child.onOptionsItemSelected(item)
override fun onBackPressed() {
if (needSave()) {
UnsavedChangesDialogFragment().apply { key() }.show(supportFragmentManager, null)
} else super.onBackPressed()
}
override fun onSupportNavigateUp(): Boolean {
if (!super.onSupportNavigateUp()) finish()
return true
}
override fun onDestroy() {
DataStore.profileCacheStore.unregisterChangeListener(this)
super.onDestroy()
}
override fun onPreferenceDataStoreChanged(store: PreferenceDataStore, key: String) {
if (key != Key.PROFILE_DIRTY) {
DataStore.dirty = true
}
}
class MyPreferenceFragmentCompat : PreferenceFragmentCompat() {
var activity: GroupSettingsActivity? = null
override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
preferenceManager.preferenceDataStore = DataStore.profileCacheStore
try {
activity = (requireActivity() as GroupSettingsActivity).apply {
createPreferences(savedInstanceState, rootKey)
}
} catch (e: Exception) {
Toast.makeText(
SagerNet.application,
"Error on createPreferences, please try again.",
Toast.LENGTH_SHORT
).show()
Logs.e(e)
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
ViewCompat.setOnApplyWindowInsetsListener(listView, ListListener)
}
override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
R.id.action_delete -> {
if (DataStore.editingId == 0L) {
requireActivity().finish()
} else {
DeleteConfirmationDialogFragment().apply {
arg(GroupIdArg(DataStore.editingId))
key()
}.show(parentFragmentManager, null)
}
true
}
R.id.action_apply -> {
runOnDefaultDispatcher {
activity?.saveAndExit()
}
true
}
else -> false
}
}
object PasswordSummaryProvider : Preference.SummaryProvider<EditTextPreference> {
override fun provideSummary(preference: EditTextPreference): CharSequence {
val text = preference.text
return if (text.isNullOrBlank()) {
preference.context.getString(androidx.preference.R.string.not_set)
} else {
"\u2022".repeat(text.length)
}
}
}
val selectProfileForAddFront = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {
if (it.resultCode == Activity.RESULT_OK) runOnDefaultDispatcher {
val profile = ProfileManager.getProfile(
it.data!!.getLongExtra(ProfileSelectActivity.EXTRA_PROFILE_ID, 0)
) ?: return@runOnDefaultDispatcher
DataStore.frontProxy = profile.id
onMainDispatcher {
frontProxyPreference.value = "3"
}
}
}
val selectProfileForAddLanding = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) {
if (it.resultCode == Activity.RESULT_OK) runOnDefaultDispatcher {
val profile = ProfileManager.getProfile(
it.data!!.getLongExtra(ProfileSelectActivity.EXTRA_PROFILE_ID, 0)
) ?: return@runOnDefaultDispatcher
DataStore.landingProxy = profile.id
onMainDispatcher {
landingProxyPreference.value = "3"
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/GroupSettingsActivity.kt | 158671785 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.os.Parcel
import android.os.Parcelable
import android.provider.OpenableColumns
import android.view.View
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AlertDialog
import androidx.core.content.FileProvider
import androidx.core.view.isVisible
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.jakewharton.processphoenix.ProcessPhoenix
import io.nekohasekai.sagernet.BuildConfig
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.*
import io.nekohasekai.sagernet.database.preference.KeyValuePair
import io.nekohasekai.sagernet.database.preference.PublicDatabase
import io.nekohasekai.sagernet.databinding.LayoutBackupBinding
import io.nekohasekai.sagernet.databinding.LayoutImportBinding
import io.nekohasekai.sagernet.databinding.LayoutProgressBinding
import io.nekohasekai.sagernet.ktx.*
import moe.matsuri.nb4a.utils.Util
import org.json.JSONArray
import org.json.JSONObject
import java.io.File
import java.util.*
class BackupFragment : NamedFragment(R.layout.layout_backup) {
override fun name0() = app.getString(R.string.backup)
var content = ""
private val exportSettings =
registerForActivityResult(ActivityResultContracts.CreateDocument()) { data ->
if (data != null) {
runOnDefaultDispatcher {
try {
requireActivity().contentResolver.openOutputStream(
data
)!!.bufferedWriter().use {
it.write(content)
}
onMainDispatcher {
snackbar(getString(R.string.action_export_msg)).show()
}
} catch (e: Exception) {
Logs.w(e)
onMainDispatcher {
snackbar(e.readableMessage).show()
}
}
}
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val binding = LayoutBackupBinding.bind(view)
binding.actionExport.setOnClickListener {
runOnDefaultDispatcher {
content = doBackup(
binding.backupConfigurations.isChecked,
binding.backupRules.isChecked,
binding.backupSettings.isChecked
)
onMainDispatcher {
startFilesForResult(
exportSettings, "husi_backup_${Date().toLocaleString()}.json"
)
}
}
}
binding.actionShare.setOnClickListener {
runOnDefaultDispatcher {
content = doBackup(
binding.backupConfigurations.isChecked,
binding.backupRules.isChecked,
binding.backupSettings.isChecked
)
app.cacheDir.mkdirs()
val cacheFile = File(
app.cacheDir, "husi_backup_${Date().toLocaleString()}.json"
)
cacheFile.writeText(content)
onMainDispatcher {
startActivity(
Intent.createChooser(
Intent(Intent.ACTION_SEND).setType("application/json")
.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
.putExtra(
Intent.EXTRA_STREAM, FileProvider.getUriForFile(
app, BuildConfig.APPLICATION_ID + ".cache", cacheFile
)
), app.getString(R.string.abc_shareactionprovider_share_with)
)
)
}
}
}
binding.actionImportFile.setOnClickListener {
startFilesForResult(importFile, "*/*")
}
}
fun Parcelable.toBase64Str(): String {
val parcel = Parcel.obtain()
writeToParcel(parcel, 0)
try {
return Util.b64EncodeUrlSafe(parcel.marshall())
} finally {
parcel.recycle()
}
}
fun doBackup(profile: Boolean, rule: Boolean, setting: Boolean): String {
val out = JSONObject().apply {
put("version", 1)
if (profile) {
put("profiles", JSONArray().apply {
SagerDatabase.proxyDao.getAll().forEach {
put(it.toBase64Str())
}
})
put("groups", JSONArray().apply {
SagerDatabase.groupDao.allGroups().forEach {
put(it.toBase64Str())
}
})
}
if (rule) {
put("rules", JSONArray().apply {
SagerDatabase.rulesDao.allRules().forEach {
put(it.toBase64Str())
}
})
}
if (setting) {
put("settings", JSONArray().apply {
PublicDatabase.kvPairDao.all().forEach {
put(it.toBase64Str())
}
})
}
}
return out.toStringPretty()
}
val importFile = registerForActivityResult(ActivityResultContracts.GetContent()) { file ->
if (file != null) {
runOnDefaultDispatcher {
startImport(file)
}
}
}
suspend fun startImport(file: Uri) {
val fileName = requireContext().contentResolver.query(file, null, null, null, null)
?.use { cursor ->
cursor.moveToFirst()
cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME).let(cursor::getString)
}
?.takeIf { it.isNotBlank() } ?: file.pathSegments.last()
.substringAfterLast('/')
.substringAfter(':')
if (!fileName.endsWith(".json")) {
onMainDispatcher {
snackbar(getString(R.string.backup_not_file, fileName)).show()
}
return
}
suspend fun invalid() = onMainDispatcher {
onMainDispatcher {
snackbar(getString(R.string.invalid_backup_file)).show()
}
}
val content = try {
JSONObject((requireContext().contentResolver.openInputStream(file) ?: return).use {
it.bufferedReader().readText()
})
} catch (e: Exception) {
Logs.w(e)
invalid()
return
}
val version = content.optInt("version", 0)
if (version < 1 || version > 1) {
invalid()
return
}
onMainDispatcher {
val import = LayoutImportBinding.inflate(layoutInflater)
if (!content.has("profiles")) {
import.backupConfigurations.isVisible = false
}
if (!content.has("rules")) {
import.backupRules.isVisible = false
}
if (!content.has("settings")) {
import.backupSettings.isVisible = false
}
MaterialAlertDialogBuilder(requireContext()).setTitle(R.string.backup_import)
.setView(import.root)
.setPositiveButton(R.string.backup_import) { _, _ ->
SagerNet.stopService()
val binding = LayoutProgressBinding.inflate(layoutInflater)
binding.content.text = getString(R.string.backup_importing)
val dialog = AlertDialog.Builder(requireContext())
.setView(binding.root)
.setCancelable(false)
.show()
runOnDefaultDispatcher {
runCatching {
finishImport(
content,
import.backupConfigurations.isChecked,
import.backupRules.isChecked,
import.backupSettings.isChecked
)
ProcessPhoenix.triggerRebirth(
requireContext(), Intent(requireContext(), MainActivity::class.java)
)
}.onFailure {
Logs.w(it)
onMainDispatcher {
alert(it.readableMessage).tryToShow()
}
}
onMainDispatcher {
dialog.dismiss()
}
}
}
.setNegativeButton(android.R.string.cancel, null)
.show()
}
}
fun finishImport(
content: JSONObject, profile: Boolean, rule: Boolean, setting: Boolean
) {
if (profile && content.has("profiles")) {
val profiles = mutableListOf<ProxyEntity>()
val jsonProfiles = content.getJSONArray("profiles")
for (i in 0 until jsonProfiles.length()) {
val data = Util.b64Decode(jsonProfiles[i] as String)
val parcel = Parcel.obtain()
parcel.unmarshall(data, 0, data.size)
parcel.setDataPosition(0)
profiles.add(ProxyEntity.CREATOR.createFromParcel(parcel))
parcel.recycle()
}
SagerDatabase.proxyDao.reset()
SagerDatabase.proxyDao.insert(profiles)
val groups = mutableListOf<ProxyGroup>()
val jsonGroups = content.getJSONArray("groups")
for (i in 0 until jsonGroups.length()) {
val data = Util.b64Decode(jsonGroups[i] as String)
val parcel = Parcel.obtain()
parcel.unmarshall(data, 0, data.size)
parcel.setDataPosition(0)
groups.add(ProxyGroup.CREATOR.createFromParcel(parcel))
parcel.recycle()
}
SagerDatabase.groupDao.reset()
SagerDatabase.groupDao.insert(groups)
}
if (rule && content.has("rules")) {
val rules = mutableListOf<RuleEntity>()
val jsonRules = content.getJSONArray("rules")
for (i in 0 until jsonRules.length()) {
val data = Util.b64Decode(jsonRules[i] as String)
val parcel = Parcel.obtain()
parcel.unmarshall(data, 0, data.size)
parcel.setDataPosition(0)
rules.add(ParcelizeBridge.createRule(parcel))
parcel.recycle()
}
SagerDatabase.rulesDao.reset()
SagerDatabase.rulesDao.insert(rules)
}
if (setting && content.has("settings")) {
val settings = mutableListOf<KeyValuePair>()
val jsonSettings = content.getJSONArray("settings")
for (i in 0 until jsonSettings.length()) {
val data = Util.b64Decode(jsonSettings[i] as String)
val parcel = Parcel.obtain()
parcel.unmarshall(data, 0, data.size)
parcel.setDataPosition(0)
settings.add(KeyValuePair.CREATOR.createFromParcel(parcel))
parcel.recycle()
}
PublicDatabase.kvPairDao.reset()
PublicDatabase.kvPairDao.insert(settings)
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/BackupFragment.kt | 1089023789 |
package io.nekohasekai.sagernet.ui
import android.app.Activity
import android.content.DialogInterface
import android.content.Intent
import android.os.Bundle
import android.os.Parcelable
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.widget.Toast
import androidx.activity.result.component1
import androidx.activity.result.component2
import androidx.activity.result.contract.ActivityResultContracts
import androidx.annotation.LayoutRes
import androidx.appcompat.app.AlertDialog
import androidx.core.view.ViewCompat
import androidx.preference.EditTextPreference
import androidx.preference.Preference
import androidx.preference.PreferenceDataStore
import androidx.preference.PreferenceFragmentCompat
import com.github.shadowsocks.plugin.Empty
import com.github.shadowsocks.plugin.fragment.AlertDialogFragment
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProfileManager
import io.nekohasekai.sagernet.database.RuleEntity
import io.nekohasekai.sagernet.database.SagerDatabase
import io.nekohasekai.sagernet.database.preference.OnPreferenceDataStoreChangeListener
import io.nekohasekai.sagernet.ktx.Logs
import io.nekohasekai.sagernet.ktx.app
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.runOnDefaultDispatcher
import io.nekohasekai.sagernet.utils.PackageCache
import io.nekohasekai.sagernet.widget.AppListPreference
import io.nekohasekai.sagernet.widget.ListListener
import io.nekohasekai.sagernet.widget.OutboundPreference
import kotlinx.parcelize.Parcelize
@Suppress("UNCHECKED_CAST")
class RouteSettingsActivity(
@LayoutRes resId: Int = R.layout.layout_settings_activity,
) : ThemedActivity(resId),
OnPreferenceDataStoreChangeListener {
fun init(packageName: String?) {
RuleEntity().apply {
if (!packageName.isNullOrBlank()) {
packages = listOf(packageName)
name = app.getString(R.string.route_for, PackageCache.loadLabel(packageName))
}
}.init()
}
fun RuleEntity.init() {
DataStore.routeName = name
DataStore.routeDomain = domains
DataStore.routeIP = ip
DataStore.routePort = port
DataStore.routeSourcePort = sourcePort
DataStore.routeNetwork = network
DataStore.routeSource = source
DataStore.routeProtocol = protocol
DataStore.routeOutboundRule = outbound
DataStore.routeOutbound = when (outbound) {
0L -> 0
-1L -> 1
-2L -> 2
else -> 3
}
DataStore.routePackages = packages.joinToString("\n")
}
fun RuleEntity.serialize() {
name = DataStore.routeName
domains = DataStore.routeDomain
ip = DataStore.routeIP
port = DataStore.routePort
sourcePort = DataStore.routeSourcePort
network = DataStore.routeNetwork
source = DataStore.routeSource
protocol = DataStore.routeProtocol
outbound = when (DataStore.routeOutbound) {
0 -> 0L
1 -> -1L
2 -> -2L
else -> DataStore.routeOutboundRule
}
packages = DataStore.routePackages.split("\n").filter { it.isNotBlank() }
if (DataStore.editingId == 0L) {
enabled = true
}
}
fun needSave(): Boolean {
if (!DataStore.dirty) return false
if (DataStore.routePackages.isBlank() &&
DataStore.routeDomain.isBlank() &&
DataStore.routeIP.isBlank() &&
DataStore.routePort.isBlank() &&
DataStore.routeSourcePort.isBlank() &&
DataStore.routeNetwork.isBlank() &&
DataStore.routeSource.isBlank() &&
DataStore.routeProtocol.isBlank() &&
DataStore.routeSSID.isBlank() &&
DataStore.routeBSSID.isBlank() &&
DataStore.routeOutbound == 0
) {
return false
}
return true
}
fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.route_preferences)
}
val selectProfileForAdd = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) { (resultCode, data) ->
if (resultCode == Activity.RESULT_OK) runOnDefaultDispatcher {
val profile = ProfileManager.getProfile(
data!!.getLongExtra(
ProfileSelectActivity.EXTRA_PROFILE_ID, 0
)
) ?: return@runOnDefaultDispatcher
DataStore.routeOutboundRule = profile.id
onMainDispatcher {
outbound.value = "3"
}
}
}
val selectAppList = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) { (_, _) ->
apps.postUpdate()
}
lateinit var outbound: OutboundPreference
lateinit var apps: AppListPreference
fun PreferenceFragmentCompat.viewCreated(view: View, savedInstanceState: Bundle?) {
outbound = findPreference(Key.ROUTE_OUTBOUND)!!
apps = findPreference(Key.ROUTE_PACKAGES)!!
outbound.setOnPreferenceChangeListener { _, newValue ->
if (newValue.toString() == "3") {
selectProfileForAdd.launch(
Intent(
this@RouteSettingsActivity, ProfileSelectActivity::class.java
)
)
false
} else {
true
}
}
apps.setOnPreferenceClickListener {
selectAppList.launch(
Intent(
this@RouteSettingsActivity, AppListActivity::class.java
)
)
true
}
}
fun PreferenceFragmentCompat.displayPreferenceDialog(preference: Preference): Boolean {
return false
}
class UnsavedChangesDialogFragment : AlertDialogFragment<Empty, Empty>() {
override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
setTitle(R.string.unsaved_changes_prompt)
setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
(requireActivity() as RouteSettingsActivity).saveAndExit()
}
}
setNegativeButton(R.string.no) { _, _ ->
requireActivity().finish()
}
setNeutralButton(android.R.string.cancel, null)
}
}
@Parcelize
data class ProfileIdArg(val ruleId: Long) : Parcelable
class DeleteConfirmationDialogFragment : AlertDialogFragment<ProfileIdArg, Empty>() {
override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
setTitle(R.string.delete_route_prompt)
setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
ProfileManager.deleteRule(arg.ruleId)
}
requireActivity().finish()
}
setNegativeButton(R.string.no, null)
}
}
companion object {
const val EXTRA_ROUTE_ID = "id"
const val EXTRA_PACKAGE_NAME = "pkg"
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setTitle(R.string.cag_route)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
if (savedInstanceState == null) {
val editingId = intent.getLongExtra(EXTRA_ROUTE_ID, 0L)
DataStore.editingId = editingId
runOnDefaultDispatcher {
if (editingId == 0L) {
init(intent.getStringExtra(EXTRA_PACKAGE_NAME))
} else {
val ruleEntity = SagerDatabase.rulesDao.getById(editingId)
if (ruleEntity == null) {
onMainDispatcher {
finish()
}
return@runOnDefaultDispatcher
}
ruleEntity.init()
}
onMainDispatcher {
supportFragmentManager.beginTransaction()
.replace(R.id.settings, MyPreferenceFragmentCompat())
.commit()
DataStore.dirty = false
DataStore.profileCacheStore.registerChangeListener(this@RouteSettingsActivity)
}
}
}
}
suspend fun saveAndExit() {
if (!needSave()) {
onMainDispatcher {
MaterialAlertDialogBuilder(this@RouteSettingsActivity).setTitle(R.string.empty_route)
.setMessage(R.string.empty_route_notice)
.setPositiveButton(android.R.string.ok, null)
.show()
}
return
}
val editingId = DataStore.editingId
if (editingId == 0L) {
if (intent.hasExtra(EXTRA_PACKAGE_NAME)) {
setResult(RESULT_OK, Intent())
}
ProfileManager.createRule(RuleEntity().apply { serialize() })
} else {
val entity = SagerDatabase.rulesDao.getById(DataStore.editingId)
if (entity == null) {
finish()
return
}
ProfileManager.updateRule(entity.apply { serialize() })
}
finish()
}
val child by lazy { supportFragmentManager.findFragmentById(R.id.settings) as MyPreferenceFragmentCompat }
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.profile_config_menu, menu)
return true
}
override fun onOptionsItemSelected(item: MenuItem) = child.onOptionsItemSelected(item)
override fun onBackPressed() {
if (needSave()) {
UnsavedChangesDialogFragment().apply { key() }.show(supportFragmentManager, null)
} else super.onBackPressed()
}
override fun onSupportNavigateUp(): Boolean {
if (!super.onSupportNavigateUp()) finish()
return true
}
override fun onDestroy() {
DataStore.profileCacheStore.unregisterChangeListener(this)
super.onDestroy()
}
override fun onPreferenceDataStoreChanged(store: PreferenceDataStore, key: String) {
if (key != Key.PROFILE_DIRTY) {
DataStore.dirty = true
}
}
class MyPreferenceFragmentCompat : PreferenceFragmentCompat() {
var activity: RouteSettingsActivity? = null
override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
preferenceManager.preferenceDataStore = DataStore.profileCacheStore
try {
activity = (requireActivity() as RouteSettingsActivity).apply {
createPreferences(savedInstanceState, rootKey)
}
} catch (e: Exception) {
Toast.makeText(
SagerNet.application,
"Error on createPreferences, please try again.",
Toast.LENGTH_SHORT
).show()
Logs.e(e)
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
ViewCompat.setOnApplyWindowInsetsListener(listView, ListListener)
activity?.apply {
viewCreated(view, savedInstanceState)
}
}
override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
R.id.action_delete -> {
if (DataStore.editingId == 0L) {
requireActivity().finish()
} else {
DeleteConfirmationDialogFragment().apply {
arg(ProfileIdArg(DataStore.editingId))
key()
}.show(parentFragmentManager, null)
}
true
}
R.id.action_apply -> {
runOnDefaultDispatcher {
activity?.saveAndExit()
}
true
}
else -> false
}
override fun onDisplayPreferenceDialog(preference: Preference) {
activity?.apply {
if (displayPreferenceDialog(preference)) return
}
super.onDisplayPreferenceDialog(preference)
}
}
object PasswordSummaryProvider : Preference.SummaryProvider<EditTextPreference> {
override fun provideSummary(preference: EditTextPreference): CharSequence {
val text = preference.text
return if (text.isNullOrBlank()) {
preference.context.getString(androidx.preference.R.string.not_set)
} else {
"\u2022".repeat(text.length)
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/RouteSettingsActivity.kt | 417906171 |
package io.nekohasekai.sagernet.ui
import android.annotation.SuppressLint
import android.content.Intent
import android.content.pm.ApplicationInfo
import android.content.pm.PackageInfo
import android.content.pm.PackageManager
import android.graphics.drawable.Drawable
import android.os.Bundle
import android.util.SparseBooleanArray
import android.view.*
import android.widget.Filter
import android.widget.Filterable
import android.widget.TextView
import androidx.annotation.UiThread
import androidx.core.util.contains
import androidx.core.util.set
import androidx.core.view.ViewCompat
import androidx.core.widget.addTextChangedListener
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.DefaultItemAnimator
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.google.android.material.snackbar.Snackbar
import com.simplecityapps.recyclerview_fastscroll.views.FastScrollRecyclerView
import io.nekohasekai.sagernet.BuildConfig
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.databinding.LayoutAppsBinding
import io.nekohasekai.sagernet.databinding.LayoutAppsItemBinding
import io.nekohasekai.sagernet.databinding.LayoutLoadingBinding
import io.nekohasekai.sagernet.ktx.Logs
import io.nekohasekai.sagernet.ktx.crossFadeFrom
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.runOnDefaultDispatcher
import io.nekohasekai.sagernet.utils.PackageCache
import io.nekohasekai.sagernet.widget.ListHolderListener
import io.nekohasekai.sagernet.widget.ListListener
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.withContext
import okhttp3.internal.closeQuietly
import org.jf.dexlib2.dexbacked.DexBackedDexFile
import org.jf.dexlib2.iface.DexFile
import java.io.File
import java.util.zip.ZipException
import java.util.zip.ZipFile
import kotlin.coroutines.coroutineContext
class AppManagerActivity : ThemedActivity() {
companion object {
@SuppressLint("StaticFieldLeak")
private var instance: AppManagerActivity? = null
private const val SWITCH = "switch"
private val cachedApps
get() = PackageCache.installedPackages.toMutableMap().apply {
remove(BuildConfig.APPLICATION_ID)
}
}
private class ProxiedApp(
private val pm: PackageManager, private val appInfo: ApplicationInfo,
val packageName: String,
) {
val name: CharSequence = appInfo.loadLabel(pm) // cached for sorting
val icon: Drawable get() = appInfo.loadIcon(pm)
val uid get() = appInfo.uid
val sys get() = (appInfo.flags and ApplicationInfo.FLAG_SYSTEM) != 0
}
private inner class AppViewHolder(val binding: LayoutAppsItemBinding) : RecyclerView.ViewHolder(
binding.root
),
View.OnClickListener {
private lateinit var item: ProxiedApp
init {
binding.root.setOnClickListener(this)
}
fun bind(app: ProxiedApp) {
item = app
binding.itemicon.setImageDrawable(app.icon)
binding.title.text = app.name
binding.desc.text = "${app.packageName} (${app.uid})"
binding.itemcheck.isChecked = isProxiedApp(app)
}
fun handlePayload(payloads: List<String>) {
if (payloads.contains(SWITCH)) binding.itemcheck.isChecked = isProxiedApp(item)
}
override fun onClick(v: View?) {
if (isProxiedApp(item)) proxiedUids.delete(item.uid) else proxiedUids[item.uid] = true
DataStore.individual = apps.filter { isProxiedApp(it) }
.joinToString("\n") { it.packageName }
appsAdapter.notifyItemRangeChanged(0, appsAdapter.itemCount, SWITCH)
}
}
private inner class AppsAdapter : RecyclerView.Adapter<AppViewHolder>(),
Filterable,
FastScrollRecyclerView.SectionedAdapter {
var filteredApps = apps
suspend fun reload() {
apps = cachedApps.map { (packageName, packageInfo) ->
coroutineContext[Job]!!.ensureActive()
ProxiedApp(packageManager, packageInfo.applicationInfo, packageName)
}.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
}
override fun onBindViewHolder(holder: AppViewHolder, position: Int) =
holder.bind(filteredApps[position])
override fun onBindViewHolder(holder: AppViewHolder, position: Int, payloads: List<Any>) {
if (payloads.isNotEmpty()) {
@Suppress("UNCHECKED_CAST") holder.handlePayload(payloads as List<String>)
return
}
onBindViewHolder(holder, position)
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AppViewHolder =
AppViewHolder(LayoutAppsItemBinding.inflate(layoutInflater, parent, false))
override fun getItemCount(): Int = filteredApps.size
private val filterImpl = object : Filter() {
override fun performFiltering(constraint: CharSequence) = FilterResults().apply {
var filteredApps = if (constraint.isEmpty()) apps else apps.filter {
it.name.contains(constraint, true) || it.packageName.contains(
constraint, true
) || it.uid.toString().contains(constraint)
}
if (!sysApps) filteredApps = filteredApps.filter { !it.sys }
count = filteredApps.size
values = filteredApps
}
override fun publishResults(constraint: CharSequence, results: FilterResults) {
@Suppress("UNCHECKED_CAST") filteredApps = results.values as List<ProxiedApp>
notifyDataSetChanged()
}
}
override fun getFilter(): Filter = filterImpl
override fun getSectionName(position: Int): String {
return filteredApps[position].name.firstOrNull()?.toString() ?: ""
}
}
private val loading by lazy { findViewById<View>(R.id.loading) }
private lateinit var binding: LayoutAppsBinding
private val proxiedUids = SparseBooleanArray()
private var loader: Job? = null
private var apps = emptyList<ProxiedApp>()
private val appsAdapter = AppsAdapter()
private fun initProxiedUids(str: String = DataStore.individual) {
proxiedUids.clear()
val apps = cachedApps
for (line in str.lineSequence()) proxiedUids[(apps[line]
?: continue).applicationInfo.uid] = true
}
private fun isProxiedApp(app: ProxiedApp) = proxiedUids[app.uid]
@UiThread
private fun loadApps() {
loader?.cancel()
loader = lifecycleScope.launchWhenCreated {
loading.crossFadeFrom(binding.list)
val adapter = binding.list.adapter as AppsAdapter
withContext(Dispatchers.IO) { adapter.reload() }
adapter.filter.filter(binding.search.text?.toString() ?: "")
binding.list.crossFadeFrom(loading)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = LayoutAppsBinding.inflate(layoutInflater)
setContentView(binding.root)
ListHolderListener.setup(this)
setSupportActionBar(binding.toolbar)
supportActionBar?.apply {
setTitle(R.string.proxied_apps)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
if (!DataStore.proxyApps) {
DataStore.proxyApps = true
}
binding.bypassGroup.check(if (DataStore.bypass) R.id.appProxyModeBypass else R.id.appProxyModeOn)
binding.bypassGroup.setOnCheckedChangeListener { _, checkedId ->
when (checkedId) {
R.id.appProxyModeDisable -> {
DataStore.proxyApps = false
finish()
}
R.id.appProxyModeOn -> DataStore.bypass = false
R.id.appProxyModeBypass -> DataStore.bypass = true
}
}
initProxiedUids()
binding.list.layoutManager = LinearLayoutManager(this, RecyclerView.VERTICAL, false)
binding.list.itemAnimator = DefaultItemAnimator()
binding.list.adapter = appsAdapter
ViewCompat.setOnApplyWindowInsetsListener(binding.root, ListListener)
binding.search.addTextChangedListener {
appsAdapter.filter.filter(it?.toString() ?: "")
}
binding.showSystemApps.isChecked = sysApps
binding.showSystemApps.setOnCheckedChangeListener { _, isChecked ->
sysApps = isChecked
appsAdapter.filter.filter(binding.search.text?.toString() ?: "")
}
instance = this
loadApps()
}
private var sysApps = true
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.per_app_proxy_menu, menu)
return true
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_scan_china_apps -> {
scanChinaApps()
return true
}
R.id.action_invert_selections -> {
runOnDefaultDispatcher {
val proxiedUidsOld = proxiedUids.clone()
for (app in apps) {
if (proxiedUidsOld.contains(app.uid)) {
proxiedUids.delete(app.uid)
} else {
proxiedUids[app.uid] = true
}
}
DataStore.individual = apps.filter { isProxiedApp(it) }
.joinToString("\n") { it.packageName }
apps = apps.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
onMainDispatcher {
appsAdapter.filter.filter(binding.search.text?.toString() ?: "")
}
}
return true
}
R.id.action_clear_selections -> {
runOnDefaultDispatcher {
proxiedUids.clear()
DataStore.individual = ""
apps = apps.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
onMainDispatcher {
appsAdapter.filter.filter(binding.search.text?.toString() ?: "")
}
}
}
R.id.action_export_clipboard -> {
val success =
SagerNet.trySetPrimaryClip("${DataStore.bypass}\n${DataStore.individual}")
Snackbar.make(
binding.list,
if (success) R.string.action_export_msg else R.string.action_export_err,
Snackbar.LENGTH_LONG
).show()
return true
}
R.id.action_import_clipboard -> {
val proxiedAppString =
SagerNet.clipboard.primaryClip?.getItemAt(0)?.text?.toString()
if (!proxiedAppString.isNullOrEmpty()) {
val i = proxiedAppString.indexOf('\n')
try {
val (enabled, apps) = if (i < 0) {
proxiedAppString to ""
} else proxiedAppString.substring(
0, i
) to proxiedAppString.substring(i + 1)
binding.bypassGroup.check(if (enabled.toBoolean()) R.id.appProxyModeBypass else R.id.appProxyModeOn)
DataStore.individual = apps
Snackbar.make(
binding.list, R.string.action_import_msg, Snackbar.LENGTH_LONG
).show()
initProxiedUids(apps)
appsAdapter.notifyItemRangeChanged(0, appsAdapter.itemCount, SWITCH)
return true
} catch (_: IllegalArgumentException) {
}
}
Snackbar.make(binding.list, R.string.action_import_err, Snackbar.LENGTH_LONG).show()
}
}
return super.onOptionsItemSelected(item)
}
@SuppressLint("SetTextI18n")
private fun scanChinaApps() {
val text: TextView
val dialog = MaterialAlertDialogBuilder(this).setView(
LayoutLoadingBinding.inflate(layoutInflater).apply {
text = loadingText
}.root
).setCancelable(false).show()
val txt = text.text.toString()
runOnDefaultDispatcher {
val chinaApps = ArrayList<Pair<PackageInfo, String>>()
val chinaRegex = ("(" + arrayOf(
"com.tencent",
"com.alibaba",
"com.umeng",
"com.qihoo",
"com.ali",
"com.alipay",
"com.amap",
"com.sina",
"com.weibo",
"com.vivo",
"com.xiaomi",
"com.huawei",
"com.taobao",
"com.secneo",
"s.h.e.l.l",
"com.stub",
"com.kiwisec",
"com.secshell",
"com.wrapper",
"cn.securitystack",
"com.mogosec",
"com.secoen",
"com.netease",
"com.mx",
"com.qq.e",
"com.baidu",
"com.bytedance",
"com.bugly",
"com.miui",
"com.oppo",
"com.coloros",
"com.iqoo",
"com.meizu",
"com.gionee",
"cn.nubia"
).joinToString("|") { "${it.replace(".", "\\.")}\\." } + ").*").toRegex()
val bypass = DataStore.bypass
val cachedApps = cachedApps
apps = cachedApps.map { (packageName, packageInfo) ->
kotlin.coroutines.coroutineContext[Job]!!.ensureActive()
ProxiedApp(packageManager, packageInfo.applicationInfo, packageName)
}.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
scan@ for ((pkg, app) in cachedApps.entries) {
/*if (!sysApps && app.applicationInfo.flags and ApplicationInfo.FLAG_SYSTEM != 0) {
continue
}*/
val index =
appsAdapter.filteredApps.indexOfFirst { it.uid == app.applicationInfo.uid }
var changed = false
onMainDispatcher {
text.text = (txt + " " + app.packageName + "\n\n" + chinaApps.map { it.second }
.reversed()
.joinToString("\n", postfix = "\n")).trim()
}
try {
val dex = File(app.applicationInfo.publicSourceDir)
val zipFile = ZipFile(dex)
var dexFile: DexFile
for (entry in zipFile.entries()) {
if (entry.name.startsWith("classes") && entry.name.endsWith(".dex")) {
val input = zipFile.getInputStream(entry).readBytes()
dexFile = try {
DexBackedDexFile.fromInputStream(null, input.inputStream())
} catch (e: Exception) {
Logs.w(e)
break
}
for (clazz in dexFile.classes) {
val clazzName = clazz.type.substring(1, clazz.type.length - 1)
.replace("/", ".")
.replace("$", ".")
if (clazzName.matches(chinaRegex)) {
chinaApps.add(
app to app.applicationInfo.loadLabel(packageManager)
.toString()
)
zipFile.closeQuietly()
if (bypass) {
changed = !proxiedUids[app.applicationInfo.uid]
proxiedUids[app.applicationInfo.uid] = true
} else {
proxiedUids.delete(app.applicationInfo.uid)
}
continue@scan
}
}
}
}
zipFile.closeQuietly()
if (bypass) {
proxiedUids.delete(app.applicationInfo.uid)
} else {
changed = !proxiedUids[index]
proxiedUids[app.applicationInfo.uid] = true
}
} catch (e: ZipException) {
Logs.w("Error in pkg ${app.packageName}:${app.versionName}", e)
continue
}
}
DataStore.individual = apps.filter { isProxiedApp(it) }
.joinToString("\n") { it.packageName }
apps = apps.sortedWith(compareBy({ !isProxiedApp(it) }, { it.name.toString() }))
onMainDispatcher {
appsAdapter.filter.filter(binding.search.text?.toString() ?: "")
dialog.dismiss()
}
}
}
override fun supportNavigateUpTo(upIntent: Intent) =
super.supportNavigateUpTo(upIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP))
override fun onKeyUp(keyCode: Int, event: KeyEvent?) = if (keyCode == KeyEvent.KEYCODE_MENU) {
if (binding.toolbar.isOverflowMenuShowing) binding.toolbar.hideOverflowMenu() else binding.toolbar.showOverflowMenu()
} else super.onKeyUp(keyCode, event)
override fun onDestroy() {
instance = null
loader?.cancel()
super.onDestroy()
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/AppManagerActivity.kt | 317527641 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import android.view.View
import androidx.core.view.ViewCompat
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.widget.ListHolderListener
class SettingsFragment : ToolbarFragment(R.layout.layout_config_settings) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
ViewCompat.setOnApplyWindowInsetsListener(view, ListHolderListener)
toolbar.setTitle(R.string.settings)
parentFragmentManager.beginTransaction()
.replace(R.id.settings, SettingsPreferenceFragment())
.commitAllowingStateLoss()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/SettingsFragment.kt | 135189882 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.graphics.Color
import android.net.Uri
import android.os.Bundle
import android.os.SystemClock
import android.provider.OpenableColumns
import android.text.SpannableStringBuilder
import android.text.Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
import android.text.format.Formatter
import android.text.style.ForegroundColorSpan
import android.view.*
import android.widget.ImageView
import android.widget.LinearLayout
import android.widget.TextView
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.widget.PopupMenu
import androidx.appcompat.widget.SearchView
import androidx.appcompat.widget.Toolbar
import androidx.core.view.isGone
import androidx.core.view.isVisible
import androidx.core.view.size
import androidx.fragment.app.Fragment
import androidx.preference.PreferenceDataStore
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.viewpager2.adapter.FragmentStateAdapter
import androidx.viewpager2.widget.ViewPager2
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.google.android.material.tabs.TabLayout
import com.google.android.material.tabs.TabLayoutMediator
import io.nekohasekai.sagernet.*
import io.nekohasekai.sagernet.aidl.TrafficData
import io.nekohasekai.sagernet.bg.BaseService
import io.nekohasekai.sagernet.bg.proto.UrlTest
import io.nekohasekai.sagernet.database.*
import io.nekohasekai.sagernet.database.preference.OnPreferenceDataStoreChangeListener
import io.nekohasekai.sagernet.databinding.LayoutAppsItemBinding
import io.nekohasekai.sagernet.databinding.LayoutProfileListBinding
import io.nekohasekai.sagernet.databinding.LayoutProgressListBinding
import io.nekohasekai.sagernet.fmt.AbstractBean
import io.nekohasekai.sagernet.fmt.toUniversalLink
import io.nekohasekai.sagernet.group.GroupUpdater
import io.nekohasekai.sagernet.group.RawUpdater
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.plugin.PluginManager
import io.nekohasekai.sagernet.ui.profile.*
import io.nekohasekai.sagernet.utils.PackageCache
import io.nekohasekai.sagernet.widget.QRCodeDialog
import io.nekohasekai.sagernet.widget.UndoSnackbarManager
import kotlinx.coroutines.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import moe.matsuri.nb4a.Protocols
import moe.matsuri.nb4a.Protocols.getProtocolColor
import moe.matsuri.nb4a.plugin.NekoPluginManager
import moe.matsuri.nb4a.proxy.config.ConfigSettingActivity
import moe.matsuri.nb4a.proxy.neko.NekoJSInterface
import moe.matsuri.nb4a.proxy.neko.NekoSettingActivity
import moe.matsuri.nb4a.proxy.neko.canShare
import moe.matsuri.nb4a.proxy.shadowtls.ShadowTLSSettingsActivity
import okhttp3.internal.closeQuietly
import java.net.InetAddress
import java.net.InetSocketAddress
import java.net.Socket
import java.net.UnknownHostException
import java.util.*
import java.util.concurrent.ConcurrentLinkedQueue
import java.util.concurrent.atomic.AtomicInteger
import java.util.zip.ZipInputStream
import kotlin.collections.set
class ConfigurationFragment @JvmOverloads constructor(
val select: Boolean = false, val selectedItem: ProxyEntity? = null, val titleRes: Int = 0
) : ToolbarFragment(R.layout.layout_group_list),
PopupMenu.OnMenuItemClickListener,
Toolbar.OnMenuItemClickListener,
SearchView.OnQueryTextListener,
OnPreferenceDataStoreChangeListener {
interface SelectCallback {
fun returnProfile(profileId: Long)
}
lateinit var adapter: GroupPagerAdapter
lateinit var tabLayout: TabLayout
lateinit var groupPager: ViewPager2
val alwaysShowAddress by lazy { DataStore.alwaysShowAddress }
fun getCurrentGroupFragment(): GroupFragment? {
return try {
childFragmentManager.findFragmentByTag("f" + DataStore.selectedGroup) as GroupFragment?
} catch (e: Exception) {
Logs.e(e)
null
}
}
val updateSelectedCallback = object : ViewPager2.OnPageChangeCallback() {
override fun onPageScrolled(
position: Int, positionOffset: Float, positionOffsetPixels: Int
) {
if (adapter.groupList.size > position) {
DataStore.selectedGroup = adapter.groupList[position].id
}
}
}
override fun onQueryTextChange(query: String): Boolean {
getCurrentGroupFragment()?.adapter?.filter(query)
return false
}
override fun onQueryTextSubmit(query: String): Boolean = false
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
if (savedInstanceState != null) {
parentFragmentManager.beginTransaction()
.setReorderingAllowed(false)
.detach(this)
.attach(this)
.commit()
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
if (!select) {
toolbar.inflateMenu(R.menu.add_profile_menu)
toolbar.setOnMenuItemClickListener(this)
} else {
toolbar.setTitle(titleRes)
toolbar.setNavigationIcon(R.drawable.ic_navigation_close)
toolbar.setNavigationOnClickListener {
requireActivity().finish()
}
}
val searchView = toolbar.findViewById<SearchView>(R.id.action_search)
if (searchView != null) {
searchView.setOnQueryTextListener(this)
searchView.maxWidth = Int.MAX_VALUE
searchView.setOnQueryTextFocusChangeListener { _, hasFocus ->
if (!hasFocus) {
// 失去焦点时取消搜索
cancelSearch(searchView)
}
}
}
groupPager = view.findViewById(R.id.group_pager)
tabLayout = view.findViewById(R.id.group_tab)
adapter = GroupPagerAdapter()
ProfileManager.addListener(adapter)
GroupManager.addListener(adapter)
groupPager.adapter = adapter
groupPager.offscreenPageLimit = 2
TabLayoutMediator(tabLayout, groupPager) { tab, position ->
if (adapter.groupList.size > position) {
tab.text = adapter.groupList[position].displayName()
}
tab.view.setOnLongClickListener { // clear toast
true
}
}.attach()
toolbar.setOnClickListener {
val fragment = getCurrentGroupFragment()
if (fragment != null) {
val selectedProxy = selectedItem?.id ?: DataStore.selectedProxy
val selectedProfileIndex =
fragment.adapter!!.configurationIdList.indexOf(selectedProxy)
if (selectedProfileIndex != -1) {
val layoutManager = fragment.layoutManager
val first = layoutManager.findFirstVisibleItemPosition()
val last = layoutManager.findLastVisibleItemPosition()
if (selectedProfileIndex !in first..last) {
fragment.configurationListView.scrollTo(selectedProfileIndex, true)
return@setOnClickListener
}
}
fragment.configurationListView.scrollTo(0)
}
}
DataStore.profileCacheStore.registerChangeListener(this)
}
override fun onPreferenceDataStoreChanged(store: PreferenceDataStore, key: String) {
runOnMainDispatcher {
// editingGroup
if (key == Key.PROFILE_GROUP) {
val targetId = DataStore.editingGroup
if (targetId > 0 && targetId != DataStore.selectedGroup) {
DataStore.selectedGroup = targetId
val targetIndex = adapter.groupList.indexOfFirst { it.id == targetId }
if (targetIndex >= 0) {
groupPager.setCurrentItem(targetIndex, false)
} else {
adapter.reload()
}
}
}
}
}
override fun onDestroy() {
DataStore.profileCacheStore.unregisterChangeListener(this)
if (::adapter.isInitialized) {
GroupManager.removeListener(adapter)
ProfileManager.removeListener(adapter)
}
super.onDestroy()
}
override fun onKeyDown(ketCode: Int, event: KeyEvent): Boolean {
val fragment = getCurrentGroupFragment()
fragment?.configurationListView?.apply {
if (!hasFocus()) requestFocus()
}
return super.onKeyDown(ketCode, event)
}
private val importFile =
registerForActivityResult(ActivityResultContracts.GetContent()) { file ->
if (file != null) runOnDefaultDispatcher {
try {
val fileName =
requireContext().contentResolver.query(file, null, null, null, null)
?.use { cursor ->
cursor.moveToFirst()
cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME)
.let(cursor::getString)
}
val proxies = mutableListOf<AbstractBean>()
if (fileName != null && fileName.endsWith(".zip")) {
// try parse wireguard zip
val zip =
ZipInputStream(requireContext().contentResolver.openInputStream(file)!!)
while (true) {
val entry = zip.nextEntry ?: break
if (entry.isDirectory) continue
val fileText = zip.bufferedReader().readText()
RawUpdater.parseRaw(fileText, entry.name)
?.let { pl -> proxies.addAll(pl) }
zip.closeEntry()
}
zip.closeQuietly()
} else {
val fileText =
requireContext().contentResolver.openInputStream(file)!!.use {
it.bufferedReader().readText()
}
RawUpdater.parseRaw(fileText, fileName ?: "")
?.let { pl -> proxies.addAll(pl) }
}
if (proxies.isEmpty()) onMainDispatcher {
snackbar(getString(R.string.no_proxies_found_in_file)).show()
} else import(proxies)
} catch (e: SubscriptionFoundException) {
(requireActivity() as MainActivity).importSubscription(Uri.parse(e.link))
} catch (e: Exception) {
Logs.w(e)
onMainDispatcher {
snackbar(e.readableMessage).show()
}
}
}
}
suspend fun import(proxies: List<AbstractBean>) {
val targetId = DataStore.selectedGroupForImport()
for (proxy in proxies) {
ProfileManager.createProfile(targetId, proxy)
}
onMainDispatcher {
DataStore.editingGroup = targetId
snackbar(
requireContext().resources.getQuantityString(
R.plurals.added, proxies.size, proxies.size
)
).show()
}
}
override fun onMenuItemClick(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_scan_qr_code -> {
startActivity(Intent(context, ScannerActivity::class.java))
}
R.id.action_import_clipboard -> {
val text = SagerNet.getClipboardText()
if (text.isBlank()) {
snackbar(getString(R.string.clipboard_empty)).show()
} else runOnDefaultDispatcher {
try {
val proxies = RawUpdater.parseRaw(text)
if (proxies.isNullOrEmpty()) onMainDispatcher {
snackbar(getString(R.string.no_proxies_found_in_clipboard)).show()
} else import(proxies)
} catch (e: SubscriptionFoundException) {
(requireActivity() as MainActivity).importSubscription(Uri.parse(e.link))
} catch (e: Exception) {
Logs.w(e)
onMainDispatcher {
snackbar(e.readableMessage).show()
}
}
}
}
R.id.action_import_file -> {
startFilesForResult(importFile, "*/*")
}
R.id.action_new_socks -> {
startActivity(Intent(requireActivity(), SocksSettingsActivity::class.java))
}
R.id.action_new_http -> {
startActivity(Intent(requireActivity(), HttpSettingsActivity::class.java))
}
R.id.action_new_ss -> {
startActivity(Intent(requireActivity(), ShadowsocksSettingsActivity::class.java))
}
R.id.action_new_vmess -> {
startActivity(Intent(requireActivity(), VMessSettingsActivity::class.java))
}
R.id.action_new_vless -> {
startActivity(Intent(requireActivity(), VMessSettingsActivity::class.java).apply {
putExtra("vless", true)
})
}
R.id.action_new_trojan -> {
startActivity(Intent(requireActivity(), TrojanSettingsActivity::class.java))
}
R.id.action_new_trojan_go -> {
startActivity(Intent(requireActivity(), TrojanGoSettingsActivity::class.java))
}
R.id.action_new_mieru -> {
startActivity(Intent(requireActivity(), MieruSettingsActivity::class.java))
}
R.id.action_new_naive -> {
startActivity(Intent(requireActivity(), NaiveSettingsActivity::class.java))
}
R.id.action_new_hysteria -> {
startActivity(Intent(requireActivity(), HysteriaSettingsActivity::class.java))
}
R.id.action_new_tuic -> {
startActivity(Intent(requireActivity(), TuicSettingsActivity::class.java))
}
R.id.action_new_ssh -> {
startActivity(Intent(requireActivity(), SSHSettingsActivity::class.java))
}
R.id.action_new_wg -> {
startActivity(Intent(requireActivity(), WireGuardSettingsActivity::class.java))
}
R.id.action_new_shadowtls -> {
startActivity(Intent(requireActivity(), ShadowTLSSettingsActivity::class.java))
}
R.id.action_new_config -> {
startActivity(Intent(requireActivity(), ConfigSettingActivity::class.java))
}
R.id.action_new_chain -> {
startActivity(Intent(requireActivity(), ChainSettingsActivity::class.java))
}
R.id.action_new_neko -> {
val context = requireContext()
lateinit var dialog: AlertDialog
val linearLayout = LinearLayout(context).apply {
orientation = LinearLayout.VERTICAL
NekoPluginManager.getProtocols().forEach { obj ->
LayoutAppsItemBinding.inflate(layoutInflater, this, true).apply {
itemcheck.isGone = true
button.isGone = false
itemicon.setImageDrawable(
PackageCache.installedApps[obj.plgId]?.loadIcon(
context.packageManager
)
)
title.text = obj.protocolId
desc.text = obj.plgId
button.setOnClickListener {
dialog.dismiss()
val intent = Intent(context, NekoSettingActivity::class.java)
intent.putExtra("plgId", obj.plgId)
intent.putExtra("protocolId", obj.protocolId)
startActivity(intent)
}
}
}
}
dialog = MaterialAlertDialogBuilder(context).setTitle(R.string.neko_plugin)
.setView(linearLayout)
.show()
}
R.id.action_update_subscription -> {
val group = DataStore.currentGroup()
if (group.type != GroupType.SUBSCRIPTION) {
snackbar(R.string.group_not_subscription).show()
Logs.e("onMenuItemClick: Group(${group.displayName()}) is not subscription")
} else {
runOnLifecycleDispatcher {
GroupUpdater.startUpdate(group, true)
}
}
}
R.id.action_clear_traffic_statistics -> {
runOnDefaultDispatcher {
val profiles = SagerDatabase.proxyDao.getByGroup(DataStore.currentGroupId())
val toClear = mutableListOf<ProxyEntity>()
if (profiles.isNotEmpty()) for (profile in profiles) {
if (profile.tx != 0L || profile.rx != 0L) {
profile.tx = 0
profile.rx = 0
toClear.add(profile)
}
}
if (toClear.isNotEmpty()) {
ProfileManager.updateProfile(toClear)
}
}
}
R.id.action_connection_test_clear_results -> {
runOnDefaultDispatcher {
val profiles = SagerDatabase.proxyDao.getByGroup(DataStore.currentGroupId())
val toClear = mutableListOf<ProxyEntity>()
if (profiles.isNotEmpty()) for (profile in profiles) {
if (profile.status != 0) {
profile.status = 0
profile.ping = 0
profile.error = null
toClear.add(profile)
}
}
if (toClear.isNotEmpty()) {
ProfileManager.updateProfile(toClear)
}
}
}
R.id.action_connection_test_delete_unavailable -> {
runOnDefaultDispatcher {
val profiles = SagerDatabase.proxyDao.getByGroup(DataStore.currentGroupId())
val toClear = mutableListOf<ProxyEntity>()
if (profiles.isNotEmpty()) for (profile in profiles) {
if (profile.status != 0 && profile.status != 1) {
toClear.add(profile)
}
}
if (toClear.isNotEmpty()) {
onMainDispatcher {
MaterialAlertDialogBuilder(requireContext()).setTitle(R.string.confirm)
.setMessage(R.string.delete_confirm_prompt)
.setPositiveButton(R.string.yes) { _, _ ->
for (profile in toClear) {
adapter.groupFragments[DataStore.selectedGroup]?.adapter?.apply {
val index = configurationIdList.indexOf(profile.id)
if (index >= 0) {
configurationIdList.removeAt(index)
configurationList.remove(profile.id)
notifyItemRemoved(index)
}
}
}
runOnDefaultDispatcher {
for (profile in toClear) {
ProfileManager.deleteProfile2(
profile.groupId, profile.id
)
}
}
}
.setNegativeButton(R.string.no, null)
.show()
}
}
}
}
R.id.action_remove_duplicate -> {
runOnDefaultDispatcher {
val profiles = SagerDatabase.proxyDao.getByGroup(DataStore.currentGroupId())
val toClear = mutableListOf<ProxyEntity>()
val uniqueProxies = LinkedHashSet<Protocols.Deduplication>()
for (pf in profiles) {
val proxy = Protocols.Deduplication(pf.requireBean(), pf.displayType())
if (!uniqueProxies.add(proxy)) {
toClear += pf
}
}
if (toClear.isNotEmpty()) {
onMainDispatcher {
MaterialAlertDialogBuilder(requireContext()).setTitle(R.string.confirm)
.setMessage(
getString(R.string.delete_confirm_prompt) + "\n" +
toClear.mapIndexedNotNull { index, proxyEntity ->
if (index < 20) {
proxyEntity.displayName()
} else if (index == 20) {
"......"
} else {
null
}
}.joinToString("\n")
)
.setPositiveButton(R.string.yes) { _, _ ->
for (profile in toClear) {
adapter.groupFragments[DataStore.selectedGroup]?.adapter?.apply {
val index = configurationIdList.indexOf(profile.id)
if (index >= 0) {
configurationIdList.removeAt(index)
configurationList.remove(profile.id)
notifyItemRemoved(index)
}
}
}
runOnDefaultDispatcher {
for (profile in toClear) {
ProfileManager.deleteProfile2(
profile.groupId, profile.id
)
}
}
}
.setNegativeButton(R.string.no, null)
.show()
}
}
}
}
R.id.action_connection_tcp_ping -> {
pingTest(false)
}
R.id.action_connection_url_test -> {
urlTest()
}
}
return true
}
inner class TestDialog {
val binding = LayoutProgressListBinding.inflate(layoutInflater)
val builder = MaterialAlertDialogBuilder(requireContext()).setView(binding.root)
.setNegativeButton(android.R.string.cancel) { _, _ ->
cancel()
}
.setOnDismissListener {
cancel()
}
.setCancelable(false)
lateinit var cancel: () -> Unit
val fragment by lazy { getCurrentGroupFragment() }
val results = Collections.synchronizedList(mutableListOf<ProxyEntity?>())
var proxyN = 0
val finishedN = AtomicInteger(0)
suspend fun insert(profile: ProxyEntity?) {
results.add(profile)
}
suspend fun update(profile: ProxyEntity) {
fragment?.configurationListView?.post {
val context = context ?: return@post
if (!isAdded) return@post
var profileStatusText: String? = null
var profileStatusColor = 0
when (profile.status) {
-1 -> {
profileStatusText = profile.error
profileStatusColor = context.getColorAttr(android.R.attr.textColorSecondary)
}
0 -> {
profileStatusText = getString(R.string.connection_test_testing)
profileStatusColor = context.getColorAttr(android.R.attr.textColorSecondary)
}
1 -> {
profileStatusText = getString(R.string.available, profile.ping)
profileStatusColor = context.getColour(R.color.material_green_500)
}
2 -> {
profileStatusText = profile.error
profileStatusColor = context.getColour(R.color.material_red_500)
}
3 -> {
val err = profile.error ?: ""
val msg = Protocols.genFriendlyMsg(err)
profileStatusText = if (msg != err) msg else getString(R.string.unavailable)
profileStatusColor = context.getColour(R.color.material_red_500)
}
}
val text = SpannableStringBuilder().apply {
append("\n" + profile.displayName())
append("\n")
append(
profile.displayType(),
ForegroundColorSpan(context.getProtocolColor(profile.type)),
SPAN_EXCLUSIVE_EXCLUSIVE
)
append(" ")
append(
profileStatusText,
ForegroundColorSpan(profileStatusColor),
SPAN_EXCLUSIVE_EXCLUSIVE
)
append("\n")
}
binding.nowTesting.text = text
binding.progress.text = "${finishedN.addAndGet(1)} / $proxyN"
}
}
}
fun stopService() {
if (DataStore.serviceState.started) SagerNet.stopService()
}
@OptIn(DelicateCoroutinesApi::class)
@Suppress("EXPERIMENTAL_API_USAGE")
fun pingTest(icmpPing: Boolean) {
val test = TestDialog()
val testJobs = mutableListOf<Job>()
val dialog = test.builder.show()
val mainJob = runOnDefaultDispatcher {
if (DataStore.serviceState.started) {
stopService()
delay(500) // wait for service stop
}
val group = DataStore.currentGroup()
val profilesUnfiltered = SagerDatabase.proxyDao.getByGroup(group.id)
test.proxyN = profilesUnfiltered.size
val profiles = ConcurrentLinkedQueue(profilesUnfiltered)
val testPool = newFixedThreadPoolContext(
DataStore.connectionTestConcurrent,
"pingTest"
)
repeat(DataStore.connectionTestConcurrent) {
testJobs.add(launch(testPool) {
while (isActive) {
val profile = profiles.poll() ?: break
if (icmpPing) {
if (!profile.requireBean().canICMPing()) {
profile.status = -1
profile.error =
app.getString(R.string.connection_test_icmp_ping_unavailable)
test.insert(profile)
continue
}
} else {
if (!profile.requireBean().canTCPing()) {
profile.status = -1
profile.error =
app.getString(R.string.connection_test_tcp_ping_unavailable)
test.insert(profile)
continue
}
}
profile.status = 0
test.insert(profile)
var address = profile.requireBean().serverAddress
if (!address.isIpAddress()) {
try {
InetAddress.getAllByName(address).apply {
if (isNotEmpty()) {
address = this[0].hostAddress
}
}
} catch (ignored: UnknownHostException) {
}
}
if (!isActive) break
if (!address.isIpAddress()) {
profile.status = 2
profile.error = app.getString(R.string.connection_test_domain_not_found)
test.update(profile)
continue
}
try {
if (icmpPing) {
// removed
} else {
val socket = Socket()
try {
socket.soTimeout = 3000
socket.bind(InetSocketAddress(0))
val start = SystemClock.elapsedRealtime()
socket.connect(
InetSocketAddress(
address, profile.requireBean().serverPort
), 3000
)
if (!isActive) break
profile.status = 1
profile.ping = (SystemClock.elapsedRealtime() - start).toInt()
test.update(profile)
} finally {
socket.closeQuietly()
}
}
} catch (e: Exception) {
if (!isActive) break
val message = e.readableMessage
if (icmpPing) {
profile.status = 2
profile.error = getString(R.string.connection_test_unreachable)
} else {
profile.status = 2
when {
!message.contains("failed:") -> profile.error =
getString(R.string.connection_test_timeout)
else -> when {
message.contains("ECONNREFUSED") -> {
profile.error =
getString(R.string.connection_test_refused)
}
message.contains("ENETUNREACH") -> {
profile.error =
getString(R.string.connection_test_unreachable)
}
else -> {
profile.status = 3
profile.error = message
}
}
}
}
test.update(profile)
}
}
})
}
testJobs.joinAll()
testPool.close()
onMainDispatcher {
dialog.dismiss()
}
}
test.cancel = {
runOnDefaultDispatcher {
test.results.filterNotNull().forEach {
try {
ProfileManager.updateProfile(it)
} catch (e: Exception) {
Logs.w(e)
}
}
GroupManager.postReload(DataStore.currentGroupId())
mainJob.cancel()
testJobs.forEach { it.cancel() }
}
}
}
@OptIn(DelicateCoroutinesApi::class)
fun urlTest() {
val test = TestDialog()
val dialog = test.builder.show()
val testJobs = mutableListOf<Job>()
val mainJob = runOnDefaultDispatcher {
if (DataStore.serviceState.started) {
stopService()
delay(500) // wait for service stop
}
val group = DataStore.currentGroup()
val profilesUnfiltered = SagerDatabase.proxyDao.getByGroup(group.id)
test.proxyN = profilesUnfiltered.size
val profiles = ConcurrentLinkedQueue(profilesUnfiltered)
val testPool = newFixedThreadPoolContext(
DataStore.connectionTestConcurrent,
"urlTest"
)
repeat(DataStore.connectionTestConcurrent) {
testJobs.add(launch(testPool) {
val urlTest = UrlTest() // note: this is NOT in bg process
while (isActive) {
val profile = profiles.poll() ?: break
profile.status = 0
test.insert(profile)
try {
val result = urlTest.doTest(profile)
profile.status = 1
profile.ping = result
} catch (e: PluginManager.PluginNotFoundException) {
profile.status = 2
profile.error = e.readableMessage
} catch (e: Exception) {
profile.status = 3
profile.error = e.readableMessage
}
test.update(profile)
}
})
}
testJobs.joinAll()
onMainDispatcher {
dialog.dismiss()
}
}
test.cancel = {
runOnDefaultDispatcher {
test.results.filterNotNull().forEach {
try {
ProfileManager.updateProfile(it)
} catch (e: Exception) {
Logs.w(e)
}
}
GroupManager.postReload(DataStore.currentGroupId())
NekoJSInterface.Default.destroyAllJsi()
mainJob.cancel()
testJobs.forEach { it.cancel() }
}
}
}
inner class GroupPagerAdapter : FragmentStateAdapter(this),
ProfileManager.Listener,
GroupManager.Listener {
var selectedGroupIndex = 0
var groupList: ArrayList<ProxyGroup> = ArrayList()
var groupFragments: HashMap<Long, GroupFragment> = HashMap()
fun reload(now: Boolean = false) {
if (!select) {
groupPager.unregisterOnPageChangeCallback(updateSelectedCallback)
}
runOnDefaultDispatcher {
var newGroupList = ArrayList(SagerDatabase.groupDao.allGroups())
if (newGroupList.isEmpty()) {
SagerDatabase.groupDao.createGroup(ProxyGroup(ungrouped = true))
newGroupList = ArrayList(SagerDatabase.groupDao.allGroups())
}
newGroupList.find { it.ungrouped }?.let {
if (SagerDatabase.proxyDao.countByGroup(it.id) == 0L) {
newGroupList.remove(it)
}
}
var selectedGroup = selectedItem?.groupId ?: DataStore.currentGroupId()
var set = false
if (selectedGroup > 0L) {
selectedGroupIndex = newGroupList.indexOfFirst { it.id == selectedGroup }
set = true
} else if (groupList.size == 1) {
selectedGroup = groupList[0].id
if (DataStore.selectedGroup != selectedGroup) {
DataStore.selectedGroup = selectedGroup
}
}
val runFunc = if (now) activity?.let { it::runOnUiThread } else groupPager::post
if (runFunc != null) {
runFunc {
groupList = newGroupList
notifyDataSetChanged()
if (set) groupPager.setCurrentItem(selectedGroupIndex, false)
val hideTab = groupList.size < 2
tabLayout.isGone = hideTab
toolbar.elevation = if (hideTab) 0F else dp2px(4).toFloat()
if (!select) {
groupPager.registerOnPageChangeCallback(updateSelectedCallback)
}
}
}
}
}
init {
reload(true)
}
override fun getItemCount(): Int {
return groupList.size
}
override fun createFragment(position: Int): Fragment {
return GroupFragment().apply {
proxyGroup = groupList[position]
groupFragments[proxyGroup.id] = this
if (position == selectedGroupIndex) {
selected = true
}
}
}
override fun getItemId(position: Int): Long {
return groupList[position].id
}
override fun containsItem(itemId: Long): Boolean {
return groupList.any { it.id == itemId }
}
override suspend fun groupAdd(group: ProxyGroup) {
tabLayout.post {
groupList.add(group)
if (groupList.any { !it.ungrouped }) tabLayout.post {
tabLayout.visibility = View.VISIBLE
}
notifyItemInserted(groupList.size - 1)
tabLayout.getTabAt(groupList.size - 1)?.select()
}
}
override suspend fun groupRemoved(groupId: Long) {
val index = groupList.indexOfFirst { it.id == groupId }
if (index == -1) return
tabLayout.post {
groupList.removeAt(index)
notifyItemRemoved(index)
}
}
override suspend fun groupUpdated(group: ProxyGroup) {
val index = groupList.indexOfFirst { it.id == group.id }
if (index == -1) return
tabLayout.post {
tabLayout.getTabAt(index)?.text = group.displayName()
}
}
override suspend fun groupUpdated(groupId: Long) = Unit
override suspend fun onAdd(profile: ProxyEntity) {
if (groupList.find { it.id == profile.groupId } == null) {
DataStore.selectedGroup = profile.groupId
reload()
}
}
override suspend fun onUpdated(data: TrafficData) = Unit
override suspend fun onUpdated(profile: ProxyEntity, noTraffic: Boolean) = Unit
override suspend fun onRemoved(groupId: Long, profileId: Long) {
val group = groupList.find { it.id == groupId } ?: return
if (group.ungrouped && SagerDatabase.proxyDao.countByGroup(groupId) == 0L) {
reload()
}
}
}
class GroupFragment : Fragment() {
lateinit var proxyGroup: ProxyGroup
var selected = false
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?,
): View {
return LayoutProfileListBinding.inflate(inflater).root
}
lateinit var undoManager: UndoSnackbarManager<ProxyEntity>
var adapter: ConfigurationAdapter? = null
override fun onSaveInstanceState(outState: Bundle) {
super.onSaveInstanceState(outState)
if (::proxyGroup.isInitialized) {
outState.putParcelable("proxyGroup", proxyGroup)
}
}
override fun onViewStateRestored(savedInstanceState: Bundle?) {
super.onViewStateRestored(savedInstanceState)
savedInstanceState?.getParcelable<ProxyGroup>("proxyGroup")?.also {
proxyGroup = it
onViewCreated(requireView(), null)
}
}
private val isEnabled: Boolean
get() {
return DataStore.serviceState.let { it.canStop || it == BaseService.State.Stopped }
}
lateinit var layoutManager: LinearLayoutManager
lateinit var configurationListView: RecyclerView
val select by lazy {
try {
(parentFragment as ConfigurationFragment).select
} catch (e: Exception) {
Logs.e(e)
false
}
}
val selectedItem by lazy {
try {
(parentFragment as ConfigurationFragment).selectedItem
} catch (e: Exception) {
Logs.e(e)
null
}
}
override fun onResume() {
super.onResume()
if (::configurationListView.isInitialized && configurationListView.size == 0) {
configurationListView.adapter = adapter
runOnDefaultDispatcher {
adapter?.reloadProfiles()
}
} else if (!::configurationListView.isInitialized) {
onViewCreated(requireView(), null)
}
checkOrderMenu()
configurationListView.requestFocus()
}
fun checkOrderMenu() {
if (select) return
val pf = requireParentFragment() as? ToolbarFragment ?: return
val menu = pf.toolbar.menu
val origin = menu.findItem(R.id.action_order_origin)
val byName = menu.findItem(R.id.action_order_by_name)
val byDelay = menu.findItem(R.id.action_order_by_delay)
when (proxyGroup.order) {
GroupOrder.ORIGIN -> {
origin.isChecked = true
}
GroupOrder.BY_NAME -> {
byName.isChecked = true
}
GroupOrder.BY_DELAY -> {
byDelay.isChecked = true
}
}
fun updateTo(order: Int) {
if (proxyGroup.order == order) return
runOnDefaultDispatcher {
proxyGroup.order = order
GroupManager.updateGroup(proxyGroup)
}
}
origin.setOnMenuItemClickListener {
it.isChecked = true
updateTo(GroupOrder.ORIGIN)
true
}
byName.setOnMenuItemClickListener {
it.isChecked = true
updateTo(GroupOrder.BY_NAME)
true
}
byDelay.setOnMenuItemClickListener {
it.isChecked = true
updateTo(GroupOrder.BY_DELAY)
true
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
if (!::proxyGroup.isInitialized) return
configurationListView = view.findViewById(R.id.configuration_list)
layoutManager = FixedLinearLayoutManager(configurationListView)
configurationListView.layoutManager = layoutManager
adapter = ConfigurationAdapter()
ProfileManager.addListener(adapter!!)
GroupManager.addListener(adapter!!)
configurationListView.adapter = adapter
configurationListView.setItemViewCacheSize(20)
if (!select) {
undoManager = UndoSnackbarManager(activity as MainActivity, adapter!!)
ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(
ItemTouchHelper.UP or ItemTouchHelper.DOWN, ItemTouchHelper.START
) {
override fun getSwipeDirs(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
): Int {
return 0
}
override fun getDragDirs(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) = if (isEnabled) super.getDragDirs(recyclerView, viewHolder) else 0
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
}
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder, target: RecyclerView.ViewHolder,
): Boolean {
adapter?.move(
viewHolder.bindingAdapterPosition, target.bindingAdapterPosition
)
return true
}
override fun clearView(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) {
super.clearView(recyclerView, viewHolder)
adapter?.commitMove()
}
}).attachToRecyclerView(configurationListView)
}
}
override fun onDestroy() {
adapter?.let {
ProfileManager.removeListener(it)
GroupManager.removeListener(it)
}
super.onDestroy()
if (!::undoManager.isInitialized) return
undoManager.flush()
}
inner class ConfigurationAdapter : RecyclerView.Adapter<ConfigurationHolder>(),
ProfileManager.Listener,
GroupManager.Listener,
UndoSnackbarManager.Interface<ProxyEntity> {
init {
setHasStableIds(true)
}
var configurationIdList: MutableList<Long> = mutableListOf()
val configurationList = HashMap<Long, ProxyEntity>()
private fun getItem(profileId: Long): ProxyEntity {
var profile = configurationList[profileId]
if (profile == null) {
profile = ProfileManager.getProfile(profileId)
if (profile != null) {
configurationList[profileId] = profile
}
}
return profile!!
}
private fun getItemAt(index: Int) = getItem(configurationIdList[index])
override fun onCreateViewHolder(
parent: ViewGroup,
viewType: Int,
): ConfigurationHolder {
return ConfigurationHolder(
LayoutInflater.from(parent.context)
.inflate(R.layout.layout_profile, parent, false)
)
}
override fun getItemId(position: Int): Long {
return configurationIdList[position]
}
override fun onBindViewHolder(holder: ConfigurationHolder, position: Int) {
try {
holder.bind(getItemAt(position))
} catch (ignored: NullPointerException) { // when group deleted
}
}
override fun getItemCount(): Int {
return configurationIdList.size
}
private val updated = HashSet<ProxyEntity>()
fun filter(name: String) {
if (name.isEmpty()) {
reloadProfiles()
return
}
configurationIdList.clear()
val lower = name.lowercase()
configurationIdList.addAll(configurationList.filter {
it.value.displayName().lowercase().contains(lower) ||
it.value.displayType().lowercase().contains(lower) ||
it.value.displayAddress().lowercase().contains(lower)
}.keys)
notifyDataSetChanged()
}
fun move(from: Int, to: Int) {
val first = getItemAt(from)
var previousOrder = first.userOrder
val (step, range) = if (from < to) Pair(1, from until to) else Pair(
-1, to + 1 downTo from
)
for (i in range) {
val next = getItemAt(i + step)
val order = next.userOrder
next.userOrder = previousOrder
previousOrder = order
configurationIdList[i] = next.id
updated.add(next)
}
first.userOrder = previousOrder
configurationIdList[to] = first.id
updated.add(first)
notifyItemMoved(from, to)
}
fun commitMove() = runOnDefaultDispatcher {
updated.forEach { SagerDatabase.proxyDao.updateProxy(it) }
updated.clear()
}
fun remove(pos: Int) {
if (pos < 0) return
configurationIdList.removeAt(pos)
notifyItemRemoved(pos)
}
override fun undo(actions: List<Pair<Int, ProxyEntity>>) {
for ((index, item) in actions) {
configurationListView.post {
configurationList[item.id] = item
configurationIdList.add(index, item.id)
notifyItemInserted(index)
}
}
}
override fun commit(actions: List<Pair<Int, ProxyEntity>>) {
val profiles = actions.map { it.second }
runOnDefaultDispatcher {
for (entity in profiles) {
ProfileManager.deleteProfile(entity.groupId, entity.id)
}
}
}
override suspend fun onAdd(profile: ProxyEntity) {
if (profile.groupId != proxyGroup.id) return
configurationListView.post {
if (::undoManager.isInitialized) {
undoManager.flush()
}
val pos = itemCount
configurationList[profile.id] = profile
configurationIdList.add(profile.id)
notifyItemInserted(pos)
}
}
override suspend fun onUpdated(profile: ProxyEntity, noTraffic: Boolean) {
if (profile.groupId != proxyGroup.id) return
val index = configurationIdList.indexOf(profile.id)
if (index < 0) return
configurationListView.post {
if (::undoManager.isInitialized) {
undoManager.flush()
}
configurationList[profile.id] = profile
notifyItemChanged(index)
//
val oldProfile = configurationList[profile.id]
if (noTraffic && oldProfile != null) {
runOnDefaultDispatcher {
onUpdated(
TrafficData(
id = profile.id,
rx = oldProfile.rx,
tx = oldProfile.tx
)
)
}
}
}
}
override suspend fun onUpdated(data: TrafficData) {
try {
val index = configurationIdList.indexOf(data.id)
if (index != -1) {
val holder = layoutManager.findViewByPosition(index)
?.let { configurationListView.getChildViewHolder(it) } as ConfigurationHolder?
if (holder != null) {
onMainDispatcher {
holder.bind(holder.entity, data)
}
}
}
} catch (e: Exception) {
Logs.w(e)
}
}
override suspend fun onRemoved(groupId: Long, profileId: Long) {
if (groupId != proxyGroup.id) return
val index = configurationIdList.indexOf(profileId)
if (index < 0) return
configurationListView.post {
configurationIdList.removeAt(index)
configurationList.remove(profileId)
notifyItemRemoved(index)
}
}
override suspend fun groupAdd(group: ProxyGroup) = Unit
override suspend fun groupRemoved(groupId: Long) = Unit
override suspend fun groupUpdated(group: ProxyGroup) {
if (group.id != proxyGroup.id) return
proxyGroup = group
reloadProfiles()
}
override suspend fun groupUpdated(groupId: Long) {
if (groupId != proxyGroup.id) return
proxyGroup = SagerDatabase.groupDao.getById(groupId)!!
reloadProfiles()
}
fun reloadProfiles() {
var newProfiles = SagerDatabase.proxyDao.getByGroup(proxyGroup.id)
val subscription = proxyGroup.subscription
when (proxyGroup.order) {
GroupOrder.BY_NAME -> {
newProfiles = newProfiles.sortedBy { it.displayName() }
}
GroupOrder.BY_DELAY -> {
newProfiles =
newProfiles.sortedBy { if (it.status == 1) it.ping else 114514 }
}
}
configurationList.clear()
configurationList.putAll(newProfiles.associateBy { it.id })
val newProfileIds = newProfiles.map { it.id }
var selectedProfileIndex = -1
if (selected) {
val selectedProxy = selectedItem?.id ?: DataStore.selectedProxy
selectedProfileIndex = newProfileIds.indexOf(selectedProxy)
}
configurationListView.post {
configurationIdList.clear()
configurationIdList.addAll(newProfileIds)
notifyDataSetChanged()
if (selectedProfileIndex != -1) {
configurationListView.scrollTo(selectedProfileIndex, true)
} else if (newProfiles.isNotEmpty()) {
configurationListView.scrollTo(0, true)
}
}
}
}
val profileAccess = Mutex()
val reloadAccess = Mutex()
inner class ConfigurationHolder(val view: View) : RecyclerView.ViewHolder(view),
PopupMenu.OnMenuItemClickListener {
lateinit var entity: ProxyEntity
val profileName: TextView = view.findViewById(R.id.profile_name)
val profileType: TextView = view.findViewById(R.id.profile_type)
val profileAddress: TextView = view.findViewById(R.id.profile_address)
val profileStatus: TextView = view.findViewById(R.id.profile_status)
val trafficText: TextView = view.findViewById(R.id.traffic_text)
val selectedView: LinearLayout = view.findViewById(R.id.selected_view)
val editButton: ImageView = view.findViewById(R.id.edit)
val shareLayout: LinearLayout = view.findViewById(R.id.share)
val shareLayer: LinearLayout = view.findViewById(R.id.share_layer)
val shareButton: ImageView = view.findViewById(R.id.shareIcon)
val removeButton: ImageView = view.findViewById(R.id.remove)
fun bind(proxyEntity: ProxyEntity, trafficData: TrafficData? = null) {
val pf = parentFragment as? ConfigurationFragment ?: return
entity = proxyEntity
if (select) {
view.setOnClickListener {
(requireActivity() as SelectCallback).returnProfile(proxyEntity.id)
}
} else {
view.setOnClickListener {
runOnDefaultDispatcher {
var update: Boolean
var lastSelected: Long
profileAccess.withLock {
update = DataStore.selectedProxy != proxyEntity.id
lastSelected = DataStore.selectedProxy
DataStore.selectedProxy = proxyEntity.id
onMainDispatcher {
selectedView.visibility = View.VISIBLE
}
}
if (update) {
ProfileManager.postUpdate(lastSelected)
if (DataStore.serviceState.canStop && reloadAccess.tryLock()) {
SagerNet.reloadService()
reloadAccess.unlock()
}
} else if (SagerNet.isTv) {
if (DataStore.serviceState.started) {
SagerNet.stopService()
} else {
SagerNet.startService()
}
}
}
}
}
profileName.text = proxyEntity.displayName()
profileType.text = proxyEntity.displayType()
profileType.setTextColor(requireContext().getProtocolColor(proxyEntity.type))
var rx = proxyEntity.rx
var tx = proxyEntity.tx
if (trafficData != null) {
// use new data
tx = trafficData.tx
rx = trafficData.rx
}
val showTraffic = rx + tx != 0L
trafficText.isVisible = showTraffic
if (showTraffic) {
trafficText.text = view.context.getString(
R.string.traffic,
Formatter.formatFileSize(view.context, tx),
Formatter.formatFileSize(view.context, rx)
)
}
var address = proxyEntity.displayAddress()
if (showTraffic && address.length >= 30) {
address = address.substring(0, 27) + "..."
}
if (proxyEntity.requireBean().name.isBlank() || !pf.alwaysShowAddress) {
address = ""
}
profileAddress.text = address
(trafficText.parent as View).isGone =
(!showTraffic || proxyEntity.status <= 0) && address.isBlank()
if (proxyEntity.status <= 0) {
if (showTraffic) {
profileStatus.text = trafficText.text
profileStatus.setTextColor(requireContext().getColorAttr(android.R.attr.textColorSecondary))
trafficText.text = ""
} else {
profileStatus.text = ""
}
} else if (proxyEntity.status == 1) {
profileStatus.text = getString(R.string.available, proxyEntity.ping)
profileStatus.setTextColor(requireContext().getColour(R.color.material_green_500))
} else {
profileStatus.setTextColor(requireContext().getColour(R.color.material_red_500))
if (proxyEntity.status == 2) {
profileStatus.text = proxyEntity.error
}
}
if (proxyEntity.status == 3) {
val err = proxyEntity.error ?: "<?>"
val msg = Protocols.genFriendlyMsg(err)
profileStatus.text = if (msg != err) msg else getString(R.string.unavailable)
profileStatus.setOnClickListener {
alert(err).tryToShow()
}
} else {
profileStatus.setOnClickListener(null)
}
editButton.setOnClickListener {
it.context.startActivity(
proxyEntity.settingIntent(
it.context, proxyGroup.type == GroupType.SUBSCRIPTION
)
)
}
removeButton.setOnClickListener {
adapter?.let {
val index = it.configurationIdList.indexOf(proxyEntity.id)
it.remove(index)
undoManager.remove(index to proxyEntity)
}
}
val selectOrChain = select || proxyEntity.type == ProxyEntity.TYPE_CHAIN
shareLayout.isGone = selectOrChain
editButton.isGone = select
removeButton.isGone = select
proxyEntity.nekoBean?.apply {
shareLayout.isGone = !canShare()
}
runOnDefaultDispatcher {
val selected = (selectedItem?.id ?: DataStore.selectedProxy) == proxyEntity.id
val started =
selected && DataStore.serviceState.started && DataStore.currentProfile == proxyEntity.id
onMainDispatcher {
editButton.isEnabled = !started
removeButton.isEnabled = !started
selectedView.visibility = if (selected) View.VISIBLE else View.INVISIBLE
}
fun showShare(anchor: View) {
val popup = PopupMenu(requireContext(), anchor)
popup.menuInflater.inflate(R.menu.profile_share_menu, popup.menu)
when {
!proxyEntity.haveStandardLink() -> {
popup.menu.findItem(R.id.action_group_qr).subMenu?.removeItem(R.id.action_standard_qr)
popup.menu.findItem(R.id.action_group_clipboard).subMenu?.removeItem(
R.id.action_standard_clipboard
)
}
!proxyEntity.haveLink() -> {
popup.menu.removeItem(R.id.action_group_qr)
popup.menu.removeItem(R.id.action_group_clipboard)
}
}
if (proxyEntity.nekoBean != null) {
popup.menu.removeItem(R.id.action_group_configuration)
}
popup.setOnMenuItemClickListener(this@ConfigurationHolder)
popup.show()
}
if (!(select || proxyEntity.type == ProxyEntity.TYPE_CHAIN)) {
onMainDispatcher {
shareLayer.setBackgroundColor(Color.TRANSPARENT)
shareButton.setImageResource(R.drawable.ic_social_share)
shareButton.setColorFilter(Color.GRAY)
shareButton.isVisible = true
shareLayout.setOnClickListener {
showShare(it)
}
}
}
}
}
var currentName = ""
fun showCode(link: String) {
QRCodeDialog(link, currentName).showAllowingStateLoss(parentFragmentManager)
}
fun export(link: String) {
val success = SagerNet.trySetPrimaryClip(link)
(activity as MainActivity).snackbar(if (success) R.string.action_export_msg else R.string.action_export_err)
.show()
}
override fun onMenuItemClick(item: MenuItem): Boolean {
try {
currentName = entity.displayName()!!
when (item.itemId) {
R.id.action_standard_qr -> showCode(entity.toStdLink()!!)
R.id.action_standard_clipboard -> export(entity.toStdLink()!!)
R.id.action_universal_qr -> showCode(entity.requireBean().toUniversalLink())
R.id.action_universal_clipboard -> export(
entity.requireBean().toUniversalLink()
)
R.id.action_config_export_clipboard -> export(entity.exportConfig().first)
R.id.action_config_export_file -> {
val cfg = entity.exportConfig()
DataStore.serverConfig = cfg.first
startFilesForResult(
(parentFragment as ConfigurationFragment).exportConfig, cfg.second
)
}
}
} catch (e: Exception) {
Logs.w(e)
(activity as MainActivity).snackbar(e.readableMessage).show()
return true
}
return true
}
}
}
private val exportConfig =
registerForActivityResult(ActivityResultContracts.CreateDocument()) { data ->
if (data != null) {
runOnDefaultDispatcher {
try {
(requireActivity() as MainActivity).contentResolver.openOutputStream(data)!!
.bufferedWriter()
.use {
it.write(DataStore.serverConfig)
}
onMainDispatcher {
snackbar(getString(R.string.action_export_msg)).show()
}
} catch (e: Exception) {
Logs.w(e)
onMainDispatcher {
snackbar(e.readableMessage).show()
}
}
}
}
}
private fun cancelSearch(searchView: SearchView) {
searchView.onActionViewCollapsed()
searchView.clearFocus()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/ConfigurationFragment.kt | 2079739297 |
package io.nekohasekai.sagernet.ui
import android.app.Activity
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.PowerManager
import android.provider.Settings
import android.text.util.Linkify
import android.view.View
import androidx.activity.result.component1
import androidx.activity.result.component2
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.view.ViewCompat
import androidx.recyclerview.widget.RecyclerView
import com.danielstone.materialaboutlibrary.MaterialAboutFragment
import com.danielstone.materialaboutlibrary.items.MaterialAboutActionItem
import com.danielstone.materialaboutlibrary.model.MaterialAboutCard
import com.danielstone.materialaboutlibrary.model.MaterialAboutList
import io.nekohasekai.sagernet.BuildConfig
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.databinding.LayoutAboutBinding
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.plugin.PluginManager.loadString
import io.nekohasekai.sagernet.utils.PackageCache
import io.nekohasekai.sagernet.widget.ListHolderListener
import libcore.Libcore
import moe.matsuri.nb4a.plugin.Plugins
class AboutFragment : ToolbarFragment(R.layout.layout_about) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val binding = LayoutAboutBinding.bind(view)
ViewCompat.setOnApplyWindowInsetsListener(view, ListHolderListener)
toolbar.setTitle(R.string.menu_about)
parentFragmentManager.beginTransaction()
.replace(R.id.about_fragment_holder, AboutContent())
.commitAllowingStateLoss()
runOnDefaultDispatcher {
val license = view.context.assets.open("LICENSE").bufferedReader().readText()
onMainDispatcher {
binding.license.text = license
Linkify.addLinks(binding.license, Linkify.EMAIL_ADDRESSES or Linkify.WEB_URLS)
}
}
}
class AboutContent : MaterialAboutFragment() {
val requestIgnoreBatteryOptimizations = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) { (resultCode, _) ->
if (resultCode == Activity.RESULT_OK) {
parentFragmentManager.beginTransaction()
.replace(R.id.about_fragment_holder, AboutContent())
.commitAllowingStateLoss()
}
}
override fun getMaterialAboutList(activityContext: Context): MaterialAboutList {
var versionName = BuildConfig.VERSION_NAME
if (!isOss) {
versionName += " ${BuildConfig.FLAVOR}"
}
if (BuildConfig.DEBUG) {
versionName += " DEBUG"
}
return MaterialAboutList.Builder()
.addCard(MaterialAboutCard.Builder()
.outline(false)
.addItem(MaterialAboutActionItem.Builder()
.icon(R.drawable.ic_baseline_update_24)
.text(R.string.app_version)
.subText(versionName)
.setOnClickAction {
requireContext().launchCustomTab(
"https://github.com/AntiNeko/CatBoxForAndroid/releases"
)
}
.build())
.addItem(MaterialAboutActionItem.Builder()
.icon(R.drawable.ic_baseline_layers_24)
.text(getString(R.string.version_x, "sing-box"))
.subText(Libcore.versionBox())
.setOnClickAction { }
.build())
.apply {
PackageCache.awaitLoadSync()
for ((_, pkg) in PackageCache.installedPluginPackages) {
try {
val pluginId = pkg.providers[0].loadString(Plugins.METADATA_KEY_ID)
if (pluginId.isNullOrBlank() || pluginId.startsWith(Plugins.AUTHORITIES_PREFIX_NEKO_PLUGIN)) continue
addItem(MaterialAboutActionItem.Builder()
.icon(R.drawable.ic_baseline_nfc_24)
.text(
getString(
R.string.version_x,
pluginId
) + " (${Plugins.displayExeProvider(pkg.packageName)})"
)
.subText("v" + pkg.versionName)
.setOnClickAction {
startActivity(Intent().apply {
action =
Settings.ACTION_APPLICATION_DETAILS_SETTINGS
data = Uri.fromParts(
"package", pkg.packageName, null
)
})
}
.build())
} catch (e: Exception) {
Logs.w(e)
}
}
}
.apply {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
val pm = app.getSystemService(Context.POWER_SERVICE) as PowerManager
if (!pm.isIgnoringBatteryOptimizations(app.packageName)) {
addItem(MaterialAboutActionItem.Builder()
.icon(R.drawable.ic_baseline_running_with_errors_24)
.text(R.string.ignore_battery_optimizations)
.subText(R.string.ignore_battery_optimizations_sum)
.setOnClickAction {
requestIgnoreBatteryOptimizations.launch(
Intent(
Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS,
Uri.parse("package:${app.packageName}")
)
)
}
.build())
}
}
}
.build())
.addCard(MaterialAboutCard.Builder()
.outline(false)
.title(R.string.project)
.addItem(MaterialAboutActionItem.Builder()
.icon(R.drawable.ic_baseline_sanitizer_24)
.text(R.string.github)
.setOnClickAction {
requireContext().launchCustomTab(
"https://github.com/xchacha20-poly1305/husi"
)
}
.build())
.addItem(MaterialAboutActionItem.Builder()
.icon(R.drawable.ic_qu_shadowsocks_foreground)
.text(R.string.telegram)
.setOnClickAction {
requireContext().launchCustomTab(
"https://t.me/AntiNek0"
)
}
.build())
.build())
.build()
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
view.findViewById<RecyclerView>(R.id.mal_recyclerview).apply {
overScrollMode = RecyclerView.OVER_SCROLL_NEVER
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/AboutFragment.kt | 2626680353 |
package io.nekohasekai.sagernet.ui.profile
import android.annotation.SuppressLint
import android.content.DialogInterface
import android.os.Bundle
import android.view.Menu
import android.view.MenuItem
import androidx.appcompat.app.AlertDialog
import androidx.core.widget.addTextChangedListener
import com.blacksquircle.ui.editorkit.insert
import com.blacksquircle.ui.language.json.JsonLanguage
import com.github.shadowsocks.plugin.Empty
import com.github.shadowsocks.plugin.fragment.AlertDialogFragment
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.databinding.LayoutEditConfigBinding
import io.nekohasekai.sagernet.ktx.getColorAttr
import io.nekohasekai.sagernet.ktx.readableMessage
import io.nekohasekai.sagernet.ktx.toStringPretty
import io.nekohasekai.sagernet.ui.ThemedActivity
import moe.matsuri.nb4a.ui.ExtendedKeyboard
import org.json.JSONObject
class ConfigEditActivity : ThemedActivity() {
var dirty = false
var key = Key.SERVER_CONFIG
class UnsavedChangesDialogFragment : AlertDialogFragment<Empty, Empty>() {
override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
setTitle(R.string.unsaved_changes_prompt)
setPositiveButton(R.string.yes) { _, _ ->
(requireActivity() as ConfigEditActivity).saveAndExit()
}
setNegativeButton(R.string.no) { _, _ ->
requireActivity().finish()
}
setNeutralButton(android.R.string.cancel, null)
}
}
lateinit var binding: LayoutEditConfigBinding
@SuppressLint("InlinedApi")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
intent?.extras?.apply {
getString("key")?.let { key = it }
}
binding = LayoutEditConfigBinding.inflate(layoutInflater)
setContentView(binding.root)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setTitle(R.string.config_settings)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
binding.editor.apply {
language = JsonLanguage()
setHorizontallyScrolling(true)
setTextContent(DataStore.profileCacheStore.getString(key)!!)
addTextChangedListener {
if (!dirty) {
dirty = true
DataStore.dirty = true
}
}
}
binding.actionTab.setOnClickListener {
binding.editor.insert(binding.editor.tab())
}
binding.actionUndo.setOnClickListener {
try {
binding.editor.undo()
} catch (_: Exception) {
}
}
binding.actionRedo.setOnClickListener {
try {
binding.editor.redo()
} catch (_: Exception) {
}
}
binding.actionFormat.setOnClickListener {
formatText()?.let {
binding.editor.setTextContent(it)
}
}
val extendedKeyboard = findViewById<ExtendedKeyboard>(R.id.extended_keyboard)
extendedKeyboard.setKeyListener { char -> binding.editor.insert(char) }
extendedKeyboard.setHasFixedSize(true)
extendedKeyboard.submitList("{},:_\"".map { it.toString() })
extendedKeyboard.setBackgroundColor(getColorAttr(R.attr.primaryOrTextPrimary))
}
fun formatText(): String? {
try {
val txt = binding.editor.text.toString()
if (txt.isBlank()) {
return ""
}
return JSONObject(txt).toStringPretty()
} catch (e: Exception) {
MaterialAlertDialogBuilder(this).setTitle(R.string.error_title)
.setMessage(e.readableMessage).show()
return null
}
}
fun saveAndExit() {
formatText()?.let {
DataStore.profileCacheStore.putString(key, it)
finish()
}
}
override fun onBackPressed() {
if (dirty) UnsavedChangesDialogFragment().apply { key() }
.show(supportFragmentManager, null) else super.onBackPressed()
}
override fun onSupportNavigateUp(): Boolean {
if (!super.onSupportNavigateUp()) finish()
return true
}
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.profile_apply_menu, menu)
return true
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_apply -> {
saveAndExit()
return true
}
}
return super.onOptionsItemSelected(item)
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/ConfigEditActivity.kt | 2094866072 |
/******************************************************************************
* *
* Copyright (C) 2021 by nekohasekai <[email protected]> *
* *
* This program 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 program 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
******************************************************************************/
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.mieru.MieruBean
import io.nekohasekai.sagernet.ktx.applyDefaultValues
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class MieruSettingsActivity : ProfileSettingsActivity<MieruBean>() {
override fun createEntity() = MieruBean().applyDefaultValues()
override fun MieruBean.init() {
DataStore.profileName = name
DataStore.serverAddress = serverAddress
DataStore.serverPort = serverPort
DataStore.serverProtocol = protocol
DataStore.serverUsername = username
DataStore.serverPassword = password
DataStore.mtu = mtu
}
override fun MieruBean.serialize() {
name = DataStore.profileName
serverAddress = DataStore.serverAddress
serverPort = DataStore.serverPort
protocol = DataStore.serverProtocol
username = DataStore.serverUsername
password = DataStore.serverPassword
mtu = DataStore.mtu
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.mieru_preferences)
findPreference<EditTextPreference>(Key.SERVER_PORT)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!.apply {
summaryProvider = PasswordSummaryProvider
}
val protocol = findPreference<SimpleMenuPreference>(Key.SERVER_PROTOCOL)!!
val mtu = findPreference<EditTextPreference>(Key.MTU)!!
mtu.isVisible = protocol.value.equals("UDP")
protocol.setOnPreferenceChangeListener { _, newValue ->
mtu.isVisible = newValue.equals("UDP")
true
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/MieruSettingsActivity.kt | 2633089224 |
package io.nekohasekai.sagernet.ui.profile
import io.nekohasekai.sagernet.fmt.trojan.TrojanBean
class TrojanSettingsActivity : StandardV2RaySettingsActivity() {
override fun createEntity() = TrojanBean()
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/TrojanSettingsActivity.kt | 3820817009 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceCategory
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.http.HttpBean
import io.nekohasekai.sagernet.fmt.trojan.TrojanBean
import io.nekohasekai.sagernet.fmt.v2ray.StandardV2RayBean
import io.nekohasekai.sagernet.fmt.v2ray.VMessBean
import moe.matsuri.nb4a.proxy.PreferenceBinding
import moe.matsuri.nb4a.proxy.PreferenceBindingManager
import moe.matsuri.nb4a.proxy.Type
import moe.matsuri.nb4a.ui.SimpleMenuPreference
abstract class StandardV2RaySettingsActivity : ProfileSettingsActivity<StandardV2RayBean>() {
var tmpBean: StandardV2RayBean? = null
private val pbm = PreferenceBindingManager()
private val name = pbm.add(PreferenceBinding(Type.Text, "name"))
private val serverAddress = pbm.add(PreferenceBinding(Type.Text, "serverAddress"))
private val serverPort = pbm.add(PreferenceBinding(Type.TextToInt, "serverPort"))
private val uuid = pbm.add(PreferenceBinding(Type.Text, "uuid"))
private val username = pbm.add(PreferenceBinding(Type.Text, "username"))
private val password = pbm.add(PreferenceBinding(Type.Text, "password"))
private val alterId = pbm.add(PreferenceBinding(Type.TextToInt, "alterId"))
private val encryption = pbm.add(PreferenceBinding(Type.Text, "encryption"))
private val type = pbm.add(PreferenceBinding(Type.Text, "type"))
private val host = pbm.add(PreferenceBinding(Type.Text, "host"))
private val path = pbm.add(PreferenceBinding(Type.Text, "path"))
private val packetEncoding = pbm.add(PreferenceBinding(Type.TextToInt, "packetEncoding"))
private val wsMaxEarlyData = pbm.add(PreferenceBinding(Type.TextToInt, "wsMaxEarlyData"))
private val earlyDataHeaderName = pbm.add(PreferenceBinding(Type.Text, "earlyDataHeaderName"))
private val security = pbm.add(PreferenceBinding(Type.Text, "security"))
private val sni = pbm.add(PreferenceBinding(Type.Text, "sni"))
private val alpn = pbm.add(PreferenceBinding(Type.Text, "alpn"))
private val certificates = pbm.add(PreferenceBinding(Type.Text, "certificates"))
private val allowInsecure = pbm.add(PreferenceBinding(Type.Bool, "allowInsecure"))
private val utlsFingerprint = pbm.add(PreferenceBinding(Type.Text, "utlsFingerprint"))
private val realityPubKey = pbm.add(PreferenceBinding(Type.Text, "realityPubKey"))
private val realityShortId = pbm.add(PreferenceBinding(Type.Text, "realityShortId"))
private val ech = pbm.add(PreferenceBinding(Type.Bool, "ech"))
private val echCfg = pbm.add(PreferenceBinding(Type.Text, "echCfg"))
override fun StandardV2RayBean.init() {
if (this is TrojanBean) {
[email protected] = "password"
[email protected] = true
}
tmpBean = this // copy bean
pbm.writeToCacheAll(this)
}
override fun StandardV2RayBean.serialize() {
pbm.fromCacheAll(this)
}
lateinit var securityCategory: PreferenceCategory
lateinit var tlsCamouflageCategory: PreferenceCategory
lateinit var echCategory: PreferenceCategory
lateinit var wsCategory: PreferenceCategory
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.standard_v2ray_preferences)
pbm.setPreferenceFragment(this)
securityCategory = findPreference(Key.SERVER_SECURITY_CATEGORY)!!
tlsCamouflageCategory = findPreference(Key.SERVER_TLS_CAMOUFLAGE_CATEGORY)!!
echCategory = findPreference(Key.SERVER_ECH_CATEGORY)!!
wsCategory = findPreference(Key.SERVER_WS_CATEGORY)!!
// vmess/vless/http/trojan
val isHttp = tmpBean is HttpBean
val isVmess = tmpBean is VMessBean && tmpBean?.isVLESS == false
val isVless = tmpBean?.isVLESS == true
serverPort.preference.apply {
this as EditTextPreference
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
alterId.preference.apply {
this as EditTextPreference
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
uuid.preference.summaryProvider = PasswordSummaryProvider
type.preference.isVisible = !isHttp
uuid.preference.isVisible = !isHttp
packetEncoding.preference.isVisible = isVmess || isVless
alterId.preference.isVisible = isVmess
encryption.preference.isVisible = isVmess || isVless
username.preference.isVisible = isHttp
password.preference.isVisible = isHttp
if (tmpBean is TrojanBean) {
uuid.preference.title = resources.getString(R.string.password)
}
encryption.preference.apply {
this as SimpleMenuPreference
if (tmpBean!!.isVLESS) {
title = resources.getString(R.string.xtls_flow)
setIcon(R.drawable.ic_baseline_stream_24)
setEntries(R.array.xtls_flow_value)
setEntryValues(R.array.xtls_flow_value)
} else {
setEntries(R.array.vmess_encryption_value)
setEntryValues(R.array.vmess_encryption_value)
}
}
// menu with listener
type.preference.apply {
updateView(type.readStringFromCache())
this as SimpleMenuPreference
setOnPreferenceChangeListener { _, newValue ->
updateView(newValue as String)
true
}
}
security.preference.apply {
updateTle(security.readStringFromCache())
this as SimpleMenuPreference
setOnPreferenceChangeListener { _, newValue ->
updateTle(newValue as String)
true
}
}
}
private fun updateView(network: String) {
host.preference.isVisible = false
path.preference.isVisible = false
wsCategory.isVisible = false
when (network) {
"tcp" -> {
host.preference.setTitle(R.string.http_host)
path.preference.setTitle(R.string.http_path)
}
"http" -> {
host.preference.setTitle(R.string.http_host)
path.preference.setTitle(R.string.http_path)
host.preference.isVisible = true
path.preference.isVisible = true
}
"ws" -> {
host.preference.setTitle(R.string.ws_host)
path.preference.setTitle(R.string.ws_path)
host.preference.isVisible = true
path.preference.isVisible = true
wsCategory.isVisible = true
}
"grpc" -> {
path.preference.setTitle(R.string.grpc_service_name)
path.preference.isVisible = true
}
"httpupgrade" -> {
host.preference.setTitle(R.string.http_upgrade_host)
path.preference.setTitle(R.string.http_upgrade_path)
host.preference.isVisible = true
path.preference.isVisible = true
}
}
}
fun updateTle(tle: String) {
val isTLS = tle == "tls"
securityCategory.isVisible = isTLS
tlsCamouflageCategory.isVisible = isTLS
echCategory.isVisible = isTLS
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/StandardV2RaySettingsActivity.kt | 428613168 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import androidx.preference.SwitchPreference
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.fmt.tuic.TuicBean
import io.nekohasekai.sagernet.ktx.applyDefaultValues
class TuicSettingsActivity : ProfileSettingsActivity<TuicBean>() {
override fun createEntity() = TuicBean().applyDefaultValues()
override fun TuicBean.init() {
DataStore.profileName = name
DataStore.serverAddress = serverAddress
DataStore.serverPort = serverPort
DataStore.serverUsername = uuid
DataStore.serverPassword = token
DataStore.serverALPN = alpn
DataStore.serverCertificates = caText
DataStore.serverUDPRelayMode = udpRelayMode
DataStore.serverCongestionController = congestionController
DataStore.serverDisableSNI = disableSNI
DataStore.serverSNI = sni
DataStore.serverReduceRTT = reduceRTT
DataStore.serverAllowInsecure = allowInsecure
DataStore.ech = ech
DataStore.echCfg = echCfg
}
override fun TuicBean.serialize() {
name = DataStore.profileName
serverAddress = DataStore.serverAddress
serverPort = DataStore.serverPort
uuid = DataStore.serverUsername
token = DataStore.serverPassword
alpn = DataStore.serverALPN
caText = DataStore.serverCertificates
udpRelayMode = DataStore.serverUDPRelayMode
congestionController = DataStore.serverCongestionController
disableSNI = DataStore.serverDisableSNI
sni = DataStore.serverSNI
reduceRTT = DataStore.serverReduceRTT
allowInsecure = DataStore.serverAllowInsecure
ech = DataStore.ech
echCfg = DataStore.echCfg
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.tuic_preferences)
val disableSNI = findPreference<SwitchPreference>(Key.SERVER_DISABLE_SNI)!!
val sni = findPreference<EditTextPreference>(Key.SERVER_SNI)!!
sni.isEnabled = !disableSNI.isChecked
disableSNI.setOnPreferenceChangeListener { _, newValue ->
sni.isEnabled = !(newValue as Boolean)
true
}
findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!.apply {
summaryProvider = PasswordSummaryProvider
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/TuicSettingsActivity.kt | 1881376546 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.socks.SOCKSBean
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class SocksSettingsActivity : ProfileSettingsActivity<SOCKSBean>() {
override fun createEntity() = SOCKSBean()
override fun SOCKSBean.init() {
DataStore.profileName = name
DataStore.serverAddress = serverAddress
DataStore.serverPort = serverPort
DataStore.serverProtocolInt = protocol
DataStore.serverUsername = username
DataStore.serverPassword = password
DataStore.profileCacheStore.putBoolean("sUoT", sUoT)
}
override fun SOCKSBean.serialize() {
name = DataStore.profileName
serverAddress = DataStore.serverAddress
serverPort = DataStore.serverPort
protocol = DataStore.serverProtocolInt
username = DataStore.serverUsername
password = DataStore.serverPassword
sUoT = DataStore.profileCacheStore.getBoolean("sUoT")
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.socks_preferences)
findPreference<EditTextPreference>(Key.SERVER_PORT)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
val password = findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!.apply {
summaryProvider = PasswordSummaryProvider
}
val protocol = findPreference<SimpleMenuPreference>(Key.SERVER_PROTOCOL)!!
fun updateProtocol(version: Int) {
password.isVisible = version == SOCKSBean.PROTOCOL_SOCKS5
}
updateProtocol(DataStore.protocolVersion)
protocol.setOnPreferenceChangeListener { _, newValue ->
updateProtocol((newValue as String).toInt())
true
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/SocksSettingsActivity.kt | 389296250 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import androidx.preference.SwitchPreference
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.hysteria.HysteriaBean
import io.nekohasekai.sagernet.ktx.applyDefaultValues
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class HysteriaSettingsActivity : ProfileSettingsActivity<HysteriaBean>() {
override fun createEntity() = HysteriaBean().applyDefaultValues()
override fun HysteriaBean.init() {
DataStore.profileName = name
DataStore.protocolVersion = protocolVersion
DataStore.serverAddress = serverAddress
DataStore.serverPorts = serverPorts
DataStore.serverObfs = obfuscation
DataStore.serverAuthType = authPayloadType
DataStore.serverProtocolInt = protocol
DataStore.serverPassword = authPayload
DataStore.serverSNI = sni
DataStore.serverALPN = alpn
DataStore.serverCertificates = caText
DataStore.serverAllowInsecure = allowInsecure
DataStore.serverUploadSpeed = uploadMbps
DataStore.serverDownloadSpeed = downloadMbps
DataStore.serverStreamReceiveWindow = streamReceiveWindow
DataStore.serverConnectionReceiveWindow = connectionReceiveWindow
DataStore.serverDisableMtuDiscovery = disableMtuDiscovery
DataStore.serverHopInterval = hopInterval
DataStore.ech = ech
DataStore.echCfg = echCfg
}
override fun HysteriaBean.serialize() {
name = DataStore.profileName
protocolVersion = DataStore.protocolVersion
serverAddress = DataStore.serverAddress
serverPorts = DataStore.serverPorts
obfuscation = DataStore.serverObfs
authPayloadType = DataStore.serverAuthType
authPayload = DataStore.serverPassword
protocol = DataStore.serverProtocolInt
sni = DataStore.serverSNI
alpn = DataStore.serverALPN
caText = DataStore.serverCertificates
allowInsecure = DataStore.serverAllowInsecure
uploadMbps = DataStore.serverUploadSpeed
downloadMbps = DataStore.serverDownloadSpeed
streamReceiveWindow = DataStore.serverStreamReceiveWindow
connectionReceiveWindow = DataStore.serverConnectionReceiveWindow
disableMtuDiscovery = DataStore.serverDisableMtuDiscovery
hopInterval = DataStore.serverHopInterval
ech = DataStore.ech
echCfg = DataStore.echCfg
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.hysteria_preferences)
val authType = findPreference<SimpleMenuPreference>(Key.SERVER_AUTH_TYPE)!!
val authPayload = findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!
authPayload.isVisible = authType.value != "${HysteriaBean.TYPE_NONE}"
authType.setOnPreferenceChangeListener { _, newValue ->
authPayload.isVisible = newValue != "${HysteriaBean.TYPE_NONE}"
true
}
val protocol = findPreference<SimpleMenuPreference>(Key.SERVER_PROTOCOL)!!
val alpn = findPreference<EditTextPreference>(Key.SERVER_ALPN)!!
fun updateVersion(v: Int) {
if (v == 2) {
authPayload.isVisible = true
//
authType.isVisible = false
protocol.isVisible = false
alpn.isVisible = false
//
findPreference<EditTextPreference>(Key.SERVER_STREAM_RECEIVE_WINDOW)!!.isVisible =
false
findPreference<EditTextPreference>(Key.SERVER_CONNECTION_RECEIVE_WINDOW)!!.isVisible =
false
findPreference<SwitchPreference>(Key.SERVER_DISABLE_MTU_DISCOVERY)!!.isVisible =
false
//
authPayload.title = resources.getString(R.string.password)
} else {
authType.isVisible = true
authPayload.isVisible = true
protocol.isVisible = true
alpn.isVisible = true
//
findPreference<EditTextPreference>(Key.SERVER_STREAM_RECEIVE_WINDOW)!!.isVisible =
true
findPreference<EditTextPreference>(Key.SERVER_CONNECTION_RECEIVE_WINDOW)!!.isVisible =
true
findPreference<SwitchPreference>(Key.SERVER_DISABLE_MTU_DISCOVERY)!!.isVisible =
true
//
authPayload.title = resources.getString(R.string.hysteria_auth_payload)
}
}
findPreference<SimpleMenuPreference>(Key.PROTOCOL_VERSION)!!.setOnPreferenceChangeListener { _, newValue ->
updateVersion(newValue.toString().toIntOrNull() ?: 1)
true
}
updateVersion(DataStore.protocolVersion)
findPreference<EditTextPreference>(Key.SERVER_UPLOAD_SPEED)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Number)
}
findPreference<EditTextPreference>(Key.SERVER_DOWNLOAD_SPEED)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Number)
}
findPreference<EditTextPreference>(Key.SERVER_STREAM_RECEIVE_WINDOW)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Number)
}
findPreference<EditTextPreference>(Key.SERVER_CONNECTION_RECEIVE_WINDOW)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Number)
}
findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!.apply {
summaryProvider = PasswordSummaryProvider
}
findPreference<EditTextPreference>(Key.SERVER_OBFS)!!.apply {
summaryProvider = PasswordSummaryProvider
}
findPreference<EditTextPreference>(Key.SERVER_HOP_INTERVAL)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Number)
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/HysteriaSettingsActivity.kt | 2074913850 |
package io.nekohasekai.sagernet.ui.profile
import io.nekohasekai.sagernet.fmt.http.HttpBean
class HttpSettingsActivity : StandardV2RaySettingsActivity() {
override fun createEntity() = HttpBean()
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/HttpSettingsActivity.kt | 2117762252 |
package io.nekohasekai.sagernet.ui.profile
import android.annotation.SuppressLint
import android.app.Activity
import android.content.Intent
import android.os.Bundle
import android.text.format.Formatter
import android.view.View
import android.view.ViewGroup
import android.widget.LinearLayout
import android.widget.TextView
import androidx.activity.result.component1
import androidx.activity.result.component2
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.view.isVisible
import androidx.preference.PreferenceFragmentCompat
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProfileManager
import io.nekohasekai.sagernet.database.ProxyEntity
import io.nekohasekai.sagernet.databinding.LayoutAddEntityBinding
import io.nekohasekai.sagernet.databinding.LayoutProfileBinding
import io.nekohasekai.sagernet.fmt.internal.ChainBean
import io.nekohasekai.sagernet.ktx.FixedLinearLayoutManager
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.runOnDefaultDispatcher
import io.nekohasekai.sagernet.ui.ProfileSelectActivity
import moe.matsuri.nb4a.Protocols.getProtocolColor
class ChainSettingsActivity : ProfileSettingsActivity<ChainBean>(R.layout.layout_chain_settings) {
override fun createEntity() = ChainBean()
val proxyList = ArrayList<ProxyEntity>()
override fun ChainBean.init() {
DataStore.profileName = name
DataStore.serverProtocol = proxies.joinToString(",")
}
override fun ChainBean.serialize() {
name = DataStore.profileName
proxies = proxyList.map { it.id }
initializeDefaultValues()
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.name_preferences)
}
lateinit var configurationList: RecyclerView
lateinit var configurationAdapter: ProxiesAdapter
lateinit var layoutManager: LinearLayoutManager
@SuppressLint("InlinedApi")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
supportActionBar!!.setTitle(R.string.chain_settings)
configurationList = findViewById(R.id.configuration_list)
layoutManager = FixedLinearLayoutManager(configurationList)
configurationList.layoutManager = layoutManager
configurationAdapter = ProxiesAdapter()
configurationList.adapter = configurationAdapter
ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(
ItemTouchHelper.UP or ItemTouchHelper.DOWN, ItemTouchHelper.START
) {
override fun getSwipeDirs(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) = if (viewHolder is ProfileHolder) {
super.getSwipeDirs(recyclerView, viewHolder)
} else 0
override fun getDragDirs(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) = if (viewHolder is ProfileHolder) {
super.getDragDirs(recyclerView, viewHolder)
} else 0
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
target: RecyclerView.ViewHolder,
): Boolean {
return if (target !is ProfileHolder) false else {
configurationAdapter.move(
viewHolder.bindingAdapterPosition, target.bindingAdapterPosition
)
true
}
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
configurationAdapter.remove(viewHolder.bindingAdapterPosition)
}
}).attachToRecyclerView(configurationList)
}
override fun PreferenceFragmentCompat.viewCreated(view: View, savedInstanceState: Bundle?) {
view.rootView.findViewById<RecyclerView>(R.id.recycler_view).apply {
(layoutParams ?: LinearLayout.LayoutParams(-1, -2)).apply {
height = -2
layoutParams = this
}
}
runOnDefaultDispatcher {
configurationAdapter.reload()
}
}
inner class ProxiesAdapter : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
suspend fun reload() {
val idList = DataStore.serverProtocol.split(",")
.mapNotNull { it.takeIf { it.isNotBlank() }?.toLong() }
if (idList.isNotEmpty()) {
val profiles = ProfileManager.getProfiles(idList).map { it.id to it }.toMap()
for (id in idList) {
proxyList.add(profiles[id] ?: continue)
}
}
onMainDispatcher {
notifyDataSetChanged()
}
}
fun move(from: Int, to: Int) {
val toMove = proxyList[to - 1]
proxyList[to - 1] = proxyList[from - 1]
proxyList[from - 1] = toMove
notifyItemMoved(from, to)
DataStore.dirty = true
}
fun remove(index: Int) {
proxyList.removeAt(index - 1)
notifyItemRemoved(index)
DataStore.dirty = true
}
override fun getItemId(position: Int): Long {
return if (position == 0) 0 else proxyList[position - 1].id
}
override fun getItemViewType(position: Int): Int {
return if (position == 0) 0 else 1
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
return if (viewType == 0) {
AddHolder(LayoutAddEntityBinding.inflate(layoutInflater, parent, false))
} else {
ProfileHolder(LayoutProfileBinding.inflate(layoutInflater, parent, false))
}
}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
if (holder is AddHolder) {
holder.bind()
} else if (holder is ProfileHolder) {
holder.bind(proxyList[position - 1])
}
}
override fun getItemCount(): Int {
return proxyList.size + 1
}
}
fun testProfileAllowed(profile: ProxyEntity): Boolean {
if (profile.id == DataStore.editingId) return false
for (entity in proxyList) {
if (testProfileContains(entity, profile)) return false
}
return true
}
fun testProfileContains(profile: ProxyEntity, anotherProfile: ProxyEntity): Boolean {
if (profile.type != 8 || anotherProfile.type != 8) return false
if (profile.id == anotherProfile.id) return true
val proxies = profile.chainBean!!.proxies
if (proxies.contains(anotherProfile.id)) return true
if (proxies.isNotEmpty()) {
for (entity in ProfileManager.getProfiles(proxies)) {
if (testProfileContains(entity, anotherProfile)) {
return true
}
}
}
return false
}
var replacing = 0
val selectProfileForAdd =
registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { (resultCode, data) ->
if (resultCode == Activity.RESULT_OK) runOnDefaultDispatcher {
DataStore.dirty = true
val profile = ProfileManager.getProfile(
data!!.getLongExtra(
ProfileSelectActivity.EXTRA_PROFILE_ID, 0
)
)!!
if (!testProfileAllowed(profile)) {
onMainDispatcher {
MaterialAlertDialogBuilder(this@ChainSettingsActivity).setTitle(R.string.circular_reference)
.setMessage(R.string.circular_reference_sum)
.setPositiveButton(android.R.string.ok, null).show()
}
} else {
configurationList.post {
if (replacing != 0) {
proxyList[replacing - 1] = profile
configurationAdapter.notifyItemChanged(replacing)
} else {
proxyList.add(profile)
configurationAdapter.notifyItemInserted(proxyList.size)
}
}
}
}
}
inner class AddHolder(val binding: LayoutAddEntityBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind() {
binding.root.setOnClickListener {
replacing = 0
selectProfileForAdd.launch(
Intent(
this@ChainSettingsActivity, ProfileSelectActivity::class.java
)
)
}
}
}
inner class ProfileHolder(binding: LayoutProfileBinding) :
RecyclerView.ViewHolder(binding.root) {
val profileName = binding.profileName
val profileType = binding.profileType
val trafficText: TextView = binding.trafficText
val editButton = binding.edit
val shareLayout = binding.share
fun bind(proxyEntity: ProxyEntity) {
profileName.text = proxyEntity.displayName()
profileType.text = proxyEntity.displayType()
profileType.setTextColor(getProtocolColor(proxyEntity.type))
val rx = proxyEntity.rx
val tx = proxyEntity.tx
val showTraffic = rx + tx != 0L
trafficText.isVisible = showTraffic
if (showTraffic) {
trafficText.text = itemView.context.getString(
R.string.traffic,
Formatter.formatFileSize(itemView.context, tx),
Formatter.formatFileSize(itemView.context, rx)
)
}
editButton.setOnClickListener {
replacing = bindingAdapterPosition
selectProfileForAdd.launch(Intent(
this@ChainSettingsActivity, ProfileSelectActivity::class.java
).apply {
putExtra(ProfileSelectActivity.EXTRA_SELECTED, proxyEntity)
})
}
shareLayout.isVisible = false
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/ChainSettingsActivity.kt | 683893067 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.ssh.SSHBean
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class SSHSettingsActivity : ProfileSettingsActivity<SSHBean>() {
override fun createEntity() = SSHBean()
override fun SSHBean.init() {
DataStore.profileName = name
DataStore.serverAddress = serverAddress
DataStore.serverPort = serverPort
DataStore.serverUsername = username
DataStore.serverAuthType = authType
DataStore.serverPassword = password
DataStore.serverPrivateKey = privateKey
DataStore.serverPassword1 = privateKeyPassphrase
DataStore.serverCertificates = publicKey
}
override fun SSHBean.serialize() {
name = DataStore.profileName
serverAddress = DataStore.serverAddress
serverPort = DataStore.serverPort
username = DataStore.serverUsername
authType = DataStore.serverAuthType
when (authType) {
SSHBean.AUTH_TYPE_NONE -> {
}
SSHBean.AUTH_TYPE_PASSWORD -> {
password = DataStore.serverPassword
}
SSHBean.AUTH_TYPE_PRIVATE_KEY -> {
privateKey = DataStore.serverPrivateKey
privateKeyPassphrase = DataStore.serverPassword1
}
}
publicKey = DataStore.serverCertificates
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.ssh_preferences)
findPreference<EditTextPreference>(Key.SERVER_PORT)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
val password = findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!.apply {
summaryProvider = PasswordSummaryProvider
}
val privateKey = findPreference<EditTextPreference>(Key.SERVER_PRIVATE_KEY)!!
val privateKeyPassphrase =
findPreference<EditTextPreference>(Key.SERVER_PASSWORD1)!!.apply {
summaryProvider = PasswordSummaryProvider
}
val authType = findPreference<SimpleMenuPreference>(Key.SERVER_AUTH_TYPE)!!
fun updateAuthType(type: Int = DataStore.serverAuthType) {
password.isVisible = type == SSHBean.AUTH_TYPE_PASSWORD
privateKey.isVisible = type == SSHBean.AUTH_TYPE_PRIVATE_KEY
privateKeyPassphrase.isVisible = type == SSHBean.AUTH_TYPE_PRIVATE_KEY
}
updateAuthType()
authType.setOnPreferenceChangeListener { _, newValue ->
updateAuthType((newValue as String).toInt())
true
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/SSHSettingsActivity.kt | 2391914108 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceCategory
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.trojan_go.TrojanGoBean
import io.nekohasekai.sagernet.ktx.app
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class TrojanGoSettingsActivity : ProfileSettingsActivity<TrojanGoBean>() {
override fun createEntity() = TrojanGoBean()
override fun TrojanGoBean.init() {
DataStore.profileName = name
DataStore.serverAddress = serverAddress
DataStore.serverPort = serverPort
DataStore.serverPassword = password
DataStore.serverSNI = sni
DataStore.serverAllowInsecure = allowInsecure
DataStore.serverNetwork = type
DataStore.serverHost = host
DataStore.serverPath = path
if (encryption.startsWith("ss;")) {
DataStore.serverEncryption = "ss"
DataStore.serverMethod = encryption.substringAfter(";").substringBefore(":")
DataStore.serverPassword1 = encryption.substringAfter(":")
} else {
DataStore.serverEncryption = encryption
}
}
override fun TrojanGoBean.serialize() {
name = DataStore.profileName
serverAddress = DataStore.serverAddress
serverPort = DataStore.serverPort
password = DataStore.serverPassword
sni = DataStore.serverSNI
allowInsecure = DataStore.serverAllowInsecure
type = DataStore.serverNetwork
host = DataStore.serverHost
path = DataStore.serverPath
encryption = when (val security = DataStore.serverEncryption) {
"ss" -> {
"ss;" + DataStore.serverMethod + ":" + DataStore.serverPassword1
}
else -> {
security
}
}
}
lateinit var network: SimpleMenuPreference
lateinit var encryprtion: SimpleMenuPreference
lateinit var wsCategory: PreferenceCategory
lateinit var ssCategory: PreferenceCategory
lateinit var method: SimpleMenuPreference
val trojanGoMethods = app.resources.getStringArray(R.array.trojan_go_methods)
val trojanGoNetworks = app.resources.getStringArray(R.array.trojan_go_networks_value)
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.trojan_go_preferences)
findPreference<EditTextPreference>(Key.SERVER_PORT)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!.apply {
summaryProvider = PasswordSummaryProvider
}
findPreference<EditTextPreference>(Key.SERVER_PASSWORD1)!!.apply {
summaryProvider = PasswordSummaryProvider
}
wsCategory = findPreference(Key.SERVER_WS_CATEGORY)!!
ssCategory = findPreference(Key.SERVER_SS_CATEGORY)!!
method = findPreference(Key.SERVER_METHOD)!!
network = findPreference(Key.SERVER_NETWORK)!!
if (network.value !in trojanGoNetworks) {
network.value = trojanGoNetworks[0]
}
updateNetwork(network.value)
network.setOnPreferenceChangeListener { _, newValue ->
updateNetwork(newValue as String)
true
}
encryprtion = findPreference(Key.SERVER_ENCRYPTION)!!
updateEncryption(encryprtion.value)
encryprtion.setOnPreferenceChangeListener { _, newValue ->
updateEncryption(newValue as String)
true
}
}
fun updateNetwork(newNet: String) {
when (newNet) {
"ws" -> {
wsCategory.isVisible = true
}
else -> {
wsCategory.isVisible = false
}
}
}
fun updateEncryption(encryption: String) {
when (encryption) {
"ss" -> {
ssCategory.isVisible = true
if (method.value !in trojanGoMethods) {
method.value = trojanGoMethods[0]
}
}
else -> {
ssCategory.isVisible = false
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/TrojanGoSettingsActivity.kt | 752384320 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.wireguard.WireGuardBean
import moe.matsuri.nb4a.proxy.PreferenceBinding
import moe.matsuri.nb4a.proxy.PreferenceBindingManager
import moe.matsuri.nb4a.proxy.Type
class WireGuardSettingsActivity : ProfileSettingsActivity<WireGuardBean>() {
override fun createEntity() = WireGuardBean()
private val pbm = PreferenceBindingManager()
private val name = pbm.add(PreferenceBinding(Type.Text, "name"))
private val serverAddress = pbm.add(PreferenceBinding(Type.Text, "serverAddress"))
private val serverPort = pbm.add(PreferenceBinding(Type.TextToInt, "serverPort"))
private val localAddress = pbm.add(PreferenceBinding(Type.Text, "localAddress"))
private val privateKey = pbm.add(PreferenceBinding(Type.Text, "privateKey"))
private val peerPublicKey = pbm.add(PreferenceBinding(Type.Text, "peerPublicKey"))
private val peerPreSharedKey = pbm.add(PreferenceBinding(Type.Text, "peerPreSharedKey"))
private val mtu = pbm.add(PreferenceBinding(Type.TextToInt, "mtu"))
private val reserved = pbm.add(PreferenceBinding(Type.Text, "reserved"))
override fun WireGuardBean.init() {
pbm.writeToCacheAll(this)
}
override fun WireGuardBean.serialize() {
pbm.fromCacheAll(this)
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.wireguard_preferences)
pbm.setPreferenceFragment(this)
(serverPort.preference as EditTextPreference)
.setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
(privateKey.preference as EditTextPreference).summaryProvider = PasswordSummaryProvider
(mtu.preference as EditTextPreference).setOnBindEditTextListener(EditTextPreferenceModifiers.Number)
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/WireGuardSettingsActivity.kt | 1331891769 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.naive.NaiveBean
class NaiveSettingsActivity : ProfileSettingsActivity<NaiveBean>() {
override fun createEntity() = NaiveBean()
override fun NaiveBean.init() {
DataStore.profileName = name
DataStore.serverAddress = serverAddress
DataStore.serverPort = serverPort
DataStore.serverUsername = username
DataStore.serverPassword = password
DataStore.serverProtocol = proto
DataStore.serverSNI = sni
DataStore.serverHeaders = extraHeaders
DataStore.serverInsecureConcurrency = insecureConcurrency
DataStore.profileCacheStore.putBoolean("sUoT", sUoT)
}
override fun NaiveBean.serialize() {
name = DataStore.profileName
serverAddress = DataStore.serverAddress
serverPort = DataStore.serverPort
username = DataStore.serverUsername
password = DataStore.serverPassword
proto = DataStore.serverProtocol
sni = DataStore.serverSNI
extraHeaders = DataStore.serverHeaders.replace("\r\n", "\n")
insecureConcurrency = DataStore.serverInsecureConcurrency
sUoT = DataStore.profileCacheStore.getBoolean("sUoT")
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.naive_preferences)
findPreference<EditTextPreference>(Key.SERVER_PORT)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
findPreference<EditTextPreference>(Key.SERVER_PASSWORD)!!.apply {
summaryProvider = PasswordSummaryProvider
}
findPreference<EditTextPreference>(Key.SERVER_INSECURE_CONCURRENCY)!!.apply {
setOnBindEditTextListener(EditTextPreferenceModifiers.Number)
}
}
override fun finish() {
if (DataStore.profileName == "喵要打开隐藏功能") {
DataStore.isExpert = true
} else if (DataStore.profileName == "喵要关闭隐藏功能") {
DataStore.isExpert = false
}
super.finish()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/NaiveSettingsActivity.kt | 3675346936 |
package io.nekohasekai.sagernet.ui.profile
import android.os.Bundle
import androidx.preference.EditTextPreference
import androidx.preference.PreferenceFragmentCompat
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.fmt.shadowsocks.ShadowsocksBean
import moe.matsuri.nb4a.proxy.PreferenceBinding
import moe.matsuri.nb4a.proxy.PreferenceBindingManager
import moe.matsuri.nb4a.proxy.Type
class ShadowsocksSettingsActivity : ProfileSettingsActivity<ShadowsocksBean>() {
override fun createEntity() = ShadowsocksBean()
private val pbm = PreferenceBindingManager()
private val name = pbm.add(PreferenceBinding(Type.Text, "name"))
private val serverAddress = pbm.add(PreferenceBinding(Type.Text, "serverAddress"))
private val serverPort = pbm.add(PreferenceBinding(Type.TextToInt, "serverPort"))
private val password = pbm.add(PreferenceBinding(Type.Text, "password"))
private val method = pbm.add(PreferenceBinding(Type.Text, "method"))
private val pluginName =
pbm.add(PreferenceBinding(Type.Text, "pluginName").apply { disable = true })
private val pluginConfig =
pbm.add(PreferenceBinding(Type.Text, "pluginConfig").apply { disable = true })
private val sUoT = pbm.add(PreferenceBinding(Type.Bool, "sUoT"))
override fun ShadowsocksBean.init() {
pbm.writeToCacheAll(this)
DataStore.profileCacheStore.putString("pluginName", plugin.substringBefore(";"))
DataStore.profileCacheStore.putString("pluginConfig", plugin.substringAfter(";"))
}
override fun ShadowsocksBean.serialize() {
pbm.fromCacheAll(this)
val pn = pluginName.readStringFromCache()
val pc = pluginConfig.readStringFromCache()
plugin = if (pn.isNotBlank()) "$pn;$pc" else ""
}
override fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
) {
addPreferencesFromResource(R.xml.shadowsocks_preferences)
pbm.setPreferenceFragment(this)
serverPort.preference.apply {
this as EditTextPreference
setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
}
password.preference.apply {
this as EditTextPreference
summaryProvider = PasswordSummaryProvider
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/ShadowsocksSettingsActivity.kt | 455946519 |
package io.nekohasekai.sagernet.ui.profile
import io.nekohasekai.sagernet.fmt.v2ray.VMessBean
class VMessSettingsActivity : StandardV2RaySettingsActivity() {
override fun createEntity() = VMessBean().apply {
if (intent?.getBooleanExtra("vless", false) == true) {
alterId = -1
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/VMessSettingsActivity.kt | 3886160386 |
package io.nekohasekai.sagernet.ui.profile
import android.annotation.SuppressLint
import android.content.DialogInterface
import android.content.Intent
import android.os.Build
import android.os.Bundle
import android.os.Parcelable
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.widget.LinearLayout
import android.widget.ScrollView
import android.widget.Toast
import androidx.activity.result.component1
import androidx.activity.result.component2
import androidx.activity.result.contract.ActivityResultContracts
import androidx.annotation.LayoutRes
import androidx.appcompat.app.AlertDialog
import androidx.core.content.pm.ShortcutInfoCompat
import androidx.core.content.pm.ShortcutManagerCompat
import androidx.core.graphics.drawable.IconCompat
import androidx.core.view.ViewCompat
import androidx.core.view.isVisible
import androidx.preference.EditTextPreference
import androidx.preference.Preference
import androidx.preference.PreferenceDataStore
import androidx.preference.PreferenceFragmentCompat
import com.github.shadowsocks.plugin.Empty
import com.github.shadowsocks.plugin.fragment.AlertDialogFragment
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.*
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.GroupManager
import io.nekohasekai.sagernet.database.ProfileManager
import io.nekohasekai.sagernet.database.SagerDatabase
import io.nekohasekai.sagernet.database.preference.OnPreferenceDataStoreChangeListener
import io.nekohasekai.sagernet.databinding.LayoutGroupItemBinding
import io.nekohasekai.sagernet.fmt.AbstractBean
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.ui.ThemedActivity
import io.nekohasekai.sagernet.widget.ListListener
import kotlinx.parcelize.Parcelize
import kotlin.properties.Delegates
@Suppress("UNCHECKED_CAST")
abstract class ProfileSettingsActivity<T : AbstractBean>(
@LayoutRes resId: Int = R.layout.layout_config_settings,
) : ThemedActivity(resId), OnPreferenceDataStoreChangeListener {
class UnsavedChangesDialogFragment : AlertDialogFragment<Empty, Empty>() {
override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
setTitle(R.string.unsaved_changes_prompt)
setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
(requireActivity() as ProfileSettingsActivity<*>).saveAndExit()
}
}
setNegativeButton(R.string.no) { _, _ ->
requireActivity().finish()
}
setNeutralButton(android.R.string.cancel, null)
}
}
@Parcelize
data class ProfileIdArg(val profileId: Long, val groupId: Long) : Parcelable
class DeleteConfirmationDialogFragment : AlertDialogFragment<ProfileIdArg, Empty>() {
override fun AlertDialog.Builder.prepare(listener: DialogInterface.OnClickListener) {
setTitle(R.string.delete_confirm_prompt)
setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
ProfileManager.deleteProfile(arg.groupId, arg.profileId)
}
requireActivity().finish()
}
setNegativeButton(R.string.no, null)
}
}
companion object {
const val EXTRA_PROFILE_ID = "id"
const val EXTRA_IS_SUBSCRIPTION = "sub"
}
abstract fun createEntity(): T
abstract fun T.init()
abstract fun T.serialize()
val proxyEntity by lazy { SagerDatabase.proxyDao.getById(DataStore.editingId) }
protected var isSubscription by Delegates.notNull<Boolean>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setTitle(R.string.profile_config)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
if (savedInstanceState == null) {
val editingId = intent.getLongExtra(EXTRA_PROFILE_ID, 0L)
isSubscription = intent.getBooleanExtra(EXTRA_IS_SUBSCRIPTION, false)
DataStore.editingId = editingId
runOnDefaultDispatcher {
if (editingId == 0L) {
DataStore.editingGroup = DataStore.selectedGroupForImport()
createEntity().applyDefaultValues().init()
} else {
if (proxyEntity == null) {
onMainDispatcher {
finish()
}
return@runOnDefaultDispatcher
}
DataStore.editingGroup = proxyEntity!!.groupId
(proxyEntity!!.requireBean() as T).init()
}
onMainDispatcher {
supportFragmentManager.beginTransaction()
.replace(R.id.settings, MyPreferenceFragmentCompat())
.commit()
}
}
}
}
open suspend fun saveAndExit() {
val editingId = DataStore.editingId
if (editingId == 0L) {
val editingGroup = DataStore.editingGroup
ProfileManager.createProfile(editingGroup, createEntity().apply { serialize() })
} else {
if (proxyEntity == null) {
finish()
return
}
if (proxyEntity!!.id == DataStore.selectedProxy) {
SagerNet.stopService()
}
ProfileManager.updateProfile(proxyEntity!!.apply { (requireBean() as T).serialize() })
}
finish()
}
val child by lazy { supportFragmentManager.findFragmentById(R.id.settings) as MyPreferenceFragmentCompat }
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.profile_config_menu, menu)
menu.findItem(R.id.action_move)?.apply {
if (DataStore.editingId != 0L // not new profile
&& SagerDatabase.groupDao.getById(DataStore.editingGroup)?.type == GroupType.BASIC // not in subscription group
&& SagerDatabase.groupDao.allGroups()
.filter { it.type == GroupType.BASIC }.size > 1 // have other basic group
) isVisible = true
}
menu.findItem(R.id.action_create_shortcut)?.apply {
if (Build.VERSION.SDK_INT >= 26 && DataStore.editingId != 0L) {
isVisible = true // not new profile
}
}
// shared menu item
menu.findItem(R.id.action_custom_outbound_json)?.isVisible = true
menu.findItem(R.id.action_custom_config_json)?.isVisible = true
return true
}
override fun onOptionsItemSelected(item: MenuItem) = child.onOptionsItemSelected(item)
override fun onBackPressed() {
if (DataStore.dirty) UnsavedChangesDialogFragment().apply { key() }
.show(supportFragmentManager, null) else super.onBackPressed()
}
override fun onSupportNavigateUp(): Boolean {
if (!super.onSupportNavigateUp()) finish()
return true
}
override fun onDestroy() {
DataStore.profileCacheStore.unregisterChangeListener(this)
super.onDestroy()
}
override fun onPreferenceDataStoreChanged(store: PreferenceDataStore, key: String) {
if (key != Key.PROFILE_DIRTY) {
DataStore.dirty = true
}
}
abstract fun PreferenceFragmentCompat.createPreferences(
savedInstanceState: Bundle?,
rootKey: String?,
)
open fun PreferenceFragmentCompat.viewCreated(view: View, savedInstanceState: Bundle?) {
}
open fun PreferenceFragmentCompat.displayPreferenceDialog(preference: Preference): Boolean {
return false
}
class MyPreferenceFragmentCompat : PreferenceFragmentCompat() {
var activity: ProfileSettingsActivity<*>? = null
override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
preferenceManager.preferenceDataStore = DataStore.profileCacheStore
try {
activity = (requireActivity() as ProfileSettingsActivity<*>).apply {
createPreferences(savedInstanceState, rootKey)
}
} catch (e: Exception) {
Toast.makeText(
SagerNet.application,
"Error on createPreferences, please try again.",
Toast.LENGTH_SHORT
).show()
Logs.e(e)
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
ViewCompat.setOnApplyWindowInsetsListener(listView, ListListener)
activity?.apply {
viewCreated(view, savedInstanceState)
DataStore.dirty = false
DataStore.profileCacheStore.registerChangeListener(this)
}
}
var callbackCustom: ((String) -> Unit)? = null
var callbackCustomOutbound: ((String) -> Unit)? = null
val resultCallbackCustom = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) { (_, _) ->
callbackCustom?.let { it(DataStore.serverCustom) }
}
val resultCallbackCustomOutbound = registerForActivityResult(
ActivityResultContracts.StartActivityForResult()
) { (_, _) ->
callbackCustomOutbound?.let { it(DataStore.serverCustomOutbound) }
}
@SuppressLint("CheckResult")
override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
R.id.action_delete -> {
if (DataStore.editingId == 0L) {
requireActivity().finish()
} else {
DeleteConfirmationDialogFragment().apply {
arg(
ProfileIdArg(
DataStore.editingId, DataStore.editingGroup
)
)
key()
}.show(parentFragmentManager, null)
}
true
}
R.id.action_apply -> {
runOnDefaultDispatcher {
activity?.saveAndExit()
}
true
}
R.id.action_custom_outbound_json -> {
activity?.proxyEntity?.apply {
val bean = requireBean()
DataStore.serverCustomOutbound = bean.customOutboundJson
callbackCustomOutbound = { bean.customOutboundJson = it }
resultCallbackCustomOutbound.launch(
Intent(
requireContext(),
ConfigEditActivity::class.java
).apply {
putExtra("key", Key.SERVER_CUSTOM_OUTBOUND)
})
}
true
}
R.id.action_custom_config_json -> {
activity?.proxyEntity?.apply {
val bean = requireBean()
DataStore.serverCustom = bean.customConfigJson
callbackCustom = { bean.customConfigJson = it }
resultCallbackCustom.launch(
Intent(
requireContext(),
ConfigEditActivity::class.java
).apply {
putExtra("key", Key.SERVER_CUSTOM)
})
}
true
}
R.id.action_create_shortcut -> {
val activity = requireActivity() as ProfileSettingsActivity<*>
val ent = activity.proxyEntity!!
val shortcut = ShortcutInfoCompat.Builder(activity, "shortcut-profile-${ent.id}")
.setShortLabel(ent.displayName())
.setLongLabel(ent.displayName())
.setIcon(
IconCompat.createWithResource(
activity, R.drawable.ic_qu_shadowsocks_launcher
)
).setIntent(Intent(
context, QuickToggleShortcut::class.java
).apply {
action = Intent.ACTION_MAIN
putExtra("profile", ent.id)
}).build()
ShortcutManagerCompat.requestPinShortcut(activity, shortcut, null)
}
R.id.action_move -> {
val activity = requireActivity() as ProfileSettingsActivity<*>
val view = LinearLayout(context).apply {
val ent = activity.proxyEntity!!
orientation = LinearLayout.VERTICAL
SagerDatabase.groupDao.allGroups()
.filter { it.type == GroupType.BASIC && it.id != ent.groupId }
.forEach { group ->
LayoutGroupItemBinding.inflate(layoutInflater, this, true).apply {
edit.isVisible = false
options.isVisible = false
groupName.text = group.displayName()
groupUpdate.text = getString(R.string.move)
groupUpdate.setOnClickListener {
runOnDefaultDispatcher {
val oldGroupId = ent.groupId
val newGroupId = group.id
ent.groupId = newGroupId
ProfileManager.updateProfile(ent)
GroupManager.postUpdate(oldGroupId) // reload
GroupManager.postUpdate(newGroupId)
DataStore.editingGroup = newGroupId // post switch animation
runOnMainDispatcher {
activity.finish()
}
}
}
}
}
}
val scrollView = ScrollView(context).apply {
addView(view)
}
MaterialAlertDialogBuilder(activity).setView(scrollView).show()
true
}
else -> false
}
override fun onDisplayPreferenceDialog(preference: Preference) {
activity?.apply {
if (displayPreferenceDialog(preference)) return
}
super.onDisplayPreferenceDialog(preference)
}
}
object PasswordSummaryProvider : Preference.SummaryProvider<EditTextPreference> {
override fun provideSummary(preference: EditTextPreference): CharSequence {
val text = preference.text
return if (text.isNullOrBlank()) {
preference.context.getString(androidx.preference.R.string.not_set)
} else {
"\u2022".repeat(text.length)
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/profile/ProfileSettingsActivity.kt | 3752911661 |
package io.nekohasekai.sagernet.ui
import android.app.Activity
import android.app.KeyguardManager
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.net.VpnService
import android.os.Bundle
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContract
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.getSystemService
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.ktx.Logs
import io.nekohasekai.sagernet.ktx.broadcastReceiver
class VpnRequestActivity : AppCompatActivity() {
private var receiver: BroadcastReceiver? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
if (getSystemService<KeyguardManager>()!!.isKeyguardLocked) {
receiver = broadcastReceiver { _, _ -> connect.launch(null) }
registerReceiver(receiver, IntentFilter(Intent.ACTION_USER_PRESENT))
} else connect.launch(null)
}
private val connect = registerForActivityResult(StartService()) {
if (it) Toast.makeText(this, R.string.vpn_permission_denied, Toast.LENGTH_LONG).show()
finish()
}
override fun onDestroy() {
super.onDestroy()
if (receiver != null) unregisterReceiver(receiver)
}
class StartService : ActivityResultContract<Void?, Boolean>() {
private var cachedIntent: Intent? = null
override fun getSynchronousResult(
context: Context,
input: Void?,
): SynchronousResult<Boolean>? {
if (DataStore.serviceMode == Key.MODE_VPN) VpnService.prepare(context)?.let { intent ->
cachedIntent = intent
return null
}
SagerNet.startService()
return SynchronousResult(false)
}
override fun createIntent(context: Context, input: Void?) =
cachedIntent!!.also { cachedIntent = null }
override fun parseResult(resultCode: Int, intent: Intent?) =
if (resultCode == Activity.RESULT_OK) {
SagerNet.startService()
false
} else {
Logs.e("Failed to start VpnService: $intent")
true
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/VpnRequestActivity.kt | 2856915353 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import androidx.appcompat.app.AlertDialog
import androidx.core.view.isVisible
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.databinding.LayoutStunBinding
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.readableMessage
import io.nekohasekai.sagernet.ktx.runOnDefaultDispatcher
import libcore.Libcore
class StunActivity : ThemedActivity() {
private lateinit var binding: LayoutStunBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = LayoutStunBinding.inflate(layoutInflater)
setContentView(binding.root)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setTitle(R.string.stun_test)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.baseline_arrow_back_24)
}
binding.stunTest.setOnClickListener {
doTest()
}
}
fun doTest() {
binding.waitLayout.isVisible = true
runOnDefaultDispatcher {
val result = try {
val _result = Libcore.stunTest(binding.natStunServer.text.toString())
if (_result!!.success) {
_result.text
} else {
throw Exception(_result.text)
}
} catch (e: Exception) {
onMainDispatcher {
AlertDialog.Builder(this@StunActivity)
.setTitle(R.string.error_title)
.setMessage(e.readableMessage)
.setPositiveButton(android.R.string.ok) { _, _ ->
finish()
}
.setOnCancelListener {
finish()
}
.runCatching { show() }
}
return@runOnDefaultDispatcher
}
onMainDispatcher {
binding.waitLayout.isVisible = false
binding.natResult.text = result
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/StunActivity.kt | 3984255260 |
package io.nekohasekai.sagernet.ui
//import io.nekohasekai.sagernet.ktx.snackbar
//import io.nekohasekai.sagernet.widget.UndoSnackbarManager
import android.content.ClipData
import android.content.ClipboardManager
import android.os.Bundle
import androidx.appcompat.app.AlertDialog
import androidx.core.view.isVisible
import com.google.android.material.snackbar.Snackbar
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.databinding.LayoutGetCertBinding
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.runOnDefaultDispatcher
import libcore.Libcore
class GetCertActivity : ThemedActivity() {
private lateinit var binding: LayoutGetCertBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = LayoutGetCertBinding.inflate(layoutInflater)
setContentView(binding.root)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setTitle(R.string.get_cert)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.baseline_arrow_back_24)
}
binding.getCert.setOnClickListener {
copyCert()
}
}
fun copyCert() {
binding.waitLayout.isVisible = true
val server = binding.pinCertServer.text.toString()
val serverName = binding.pinCertServerName.text.toString()
runOnDefaultDispatcher {
try {
val certificate = Libcore.pinCert(server, serverName)
if (certificate.isNullOrEmpty()) {
onMainDispatcher {
binding.waitLayout.isVisible = false
AlertDialog.Builder(this@GetCertActivity)
.setTitle(R.string.error_title)
.setMessage(R.string.get_cert_fail)
.setPositiveButton(android.R.string.ok) { _, _ ->
// finish()
}
.setOnCancelListener {
// finish()
}
.runCatching { show() }
}
} else {
// 复制到剪贴板
val clipboardManager = getSystemService(CLIPBOARD_SERVICE) as ClipboardManager
val clipData = ClipData.newPlainText("Certificate", certificate)
clipboardManager.setPrimaryClip(clipData)
val snackbar = Snackbar.make(
binding.root,
R.string.get_cert_success,
Snackbar.LENGTH_SHORT
)
snackbar.show()
onMainDispatcher {
binding.waitLayout.isVisible = false
}
}
} catch (e: Exception) {
onMainDispatcher {
binding.waitLayout.isVisible = false
}
}
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/GetCertActivity.kt | 43521640 |
package io.nekohasekai.sagernet.ui
import android.content.res.Configuration
import android.os.Bundle
import android.widget.TextView
import androidx.annotation.StringRes
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import com.google.android.material.snackbar.Snackbar
import io.nekohasekai.sagernet.utils.Theme
abstract class ThemedActivity : AppCompatActivity {
constructor() : super()
constructor(contentLayoutId: Int) : super(contentLayoutId)
var themeResId = 0
var uiMode = 0
open val isDialog = false
override fun onCreate(savedInstanceState: Bundle?) {
if (!isDialog) {
Theme.apply(this)
} else {
Theme.applyDialog(this)
}
Theme.applyNightTheme()
super.onCreate(savedInstanceState)
uiMode = resources.configuration.uiMode
}
override fun setTheme(resId: Int) {
super.setTheme(resId)
themeResId = resId
}
override fun onConfigurationChanged(newConfig: Configuration) {
super.onConfigurationChanged(newConfig)
if (newConfig.uiMode != uiMode) {
uiMode = newConfig.uiMode
ActivityCompat.recreate(this)
}
}
fun snackbar(@StringRes resId: Int): Snackbar = snackbar("").setText(resId)
fun snackbar(text: CharSequence): Snackbar = snackbarInternal(text).apply {
view.findViewById<TextView>(com.google.android.material.R.id.snackbar_text).apply {
maxLines = 10
}
}
internal open fun snackbarInternal(text: CharSequence): Snackbar = throw NotImplementedError()
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/ThemedActivity.kt | 4066079919 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import android.view.KeyEvent
import android.view.View
import androidx.appcompat.widget.Toolbar
import androidx.core.view.GravityCompat
import androidx.fragment.app.Fragment
import io.nekohasekai.sagernet.R
open class ToolbarFragment : Fragment {
constructor() : super()
constructor(contentLayoutId: Int) : super(contentLayoutId)
lateinit var toolbar: Toolbar
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
toolbar = view.findViewById(R.id.toolbar)
toolbar.setNavigationIcon(R.drawable.ic_navigation_menu)
toolbar.setNavigationOnClickListener {
(activity as MainActivity).binding.drawerLayout.openDrawer(GravityCompat.START)
}
}
open fun onKeyDown(ketCode: Int, event: KeyEvent) = false
open fun onBackPressed(): Boolean = false
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/ToolbarFragment.kt | 915431667 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.os.Bundle
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import androidx.appcompat.widget.Toolbar
import androidx.core.view.ViewCompat
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProfileManager
import io.nekohasekai.sagernet.database.RuleEntity
import io.nekohasekai.sagernet.database.SagerDatabase
import io.nekohasekai.sagernet.databinding.LayoutEmptyRouteBinding
import io.nekohasekai.sagernet.databinding.LayoutRouteItemBinding
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.widget.ListHolderListener
import io.nekohasekai.sagernet.widget.UndoSnackbarManager
class RouteFragment : ToolbarFragment(R.layout.layout_route), Toolbar.OnMenuItemClickListener {
lateinit var activity: MainActivity
lateinit var ruleListView: RecyclerView
lateinit var ruleAdapter: RuleAdapter
lateinit var undoManager: UndoSnackbarManager<RuleEntity>
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
activity = requireActivity() as MainActivity
ViewCompat.setOnApplyWindowInsetsListener(view, ListHolderListener)
toolbar.setTitle(R.string.menu_route)
toolbar.inflateMenu(R.menu.add_route_menu)
toolbar.setOnMenuItemClickListener(this)
ruleListView = view.findViewById(R.id.route_list)
ruleListView.layoutManager = FixedLinearLayoutManager(ruleListView)
ruleAdapter = RuleAdapter()
ProfileManager.addListener(ruleAdapter)
ruleListView.adapter = ruleAdapter
undoManager = UndoSnackbarManager(activity, ruleAdapter)
ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(
ItemTouchHelper.UP or ItemTouchHelper.DOWN,
ItemTouchHelper.START
) {
override fun getSwipeDirs(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) = if (viewHolder is RuleAdapter.DocumentHolder) {
0
} else {
super.getSwipeDirs(recyclerView, viewHolder)
}
override fun getDragDirs(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) = if (viewHolder is RuleAdapter.DocumentHolder) {
0
} else {
super.getDragDirs(recyclerView, viewHolder)
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
val index = viewHolder.bindingAdapterPosition
ruleAdapter.remove(index)
undoManager.remove(index to (viewHolder as RuleAdapter.RuleHolder).rule)
}
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder, target: RecyclerView.ViewHolder,
): Boolean {
return if (target is RuleAdapter.DocumentHolder) {
false
} else {
ruleAdapter.move(
viewHolder.bindingAdapterPosition,
target.bindingAdapterPosition
)
true
}
}
override fun clearView(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
) {
super.clearView(recyclerView, viewHolder)
ruleAdapter.commitMove()
}
}).attachToRecyclerView(ruleListView)
}
override fun onDestroy() {
if (::ruleAdapter.isInitialized) {
ProfileManager.removeListener(ruleAdapter)
}
super.onDestroy()
}
override fun onMenuItemClick(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_new_route -> {
startActivity(Intent(context, RouteSettingsActivity::class.java))
}
R.id.action_reset_route -> {
MaterialAlertDialogBuilder(activity).setTitle(R.string.confirm)
.setMessage(R.string.clear_profiles_message)
.setPositiveButton(R.string.yes) { _, _ ->
runOnDefaultDispatcher {
SagerDatabase.rulesDao.reset()
DataStore.rulesFirstCreate = false
ruleAdapter.reload()
}
}
.setNegativeButton(R.string.no, null)
.show()
}
R.id.action_manage_assets -> {
startActivity(Intent(requireContext(), AssetsActivity::class.java))
}
}
return true
}
inner class RuleAdapter : RecyclerView.Adapter<RecyclerView.ViewHolder>(),
ProfileManager.RuleListener, UndoSnackbarManager.Interface<RuleEntity> {
val ruleList = ArrayList<RuleEntity>()
suspend fun reload() {
val rules = ProfileManager.getRules()
ruleListView.post {
ruleList.clear()
ruleList.addAll(rules)
ruleAdapter.notifyDataSetChanged()
}
}
init {
runOnDefaultDispatcher {
reload()
}
}
override fun onCreateViewHolder(
parent: ViewGroup,
viewType: Int,
): RecyclerView.ViewHolder {
return if (viewType == 0) {
DocumentHolder(LayoutEmptyRouteBinding.inflate(layoutInflater, parent, false))
} else {
RuleHolder(LayoutRouteItemBinding.inflate(layoutInflater, parent, false))
}
}
override fun getItemViewType(position: Int): Int {
if (position == 0) return 0
return 1
}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
if (holder is DocumentHolder) {
holder.bind()
} else if (holder is RuleHolder) {
holder.bind(ruleList[position - 1])
}
}
override fun getItemCount(): Int {
return ruleList.size + 1
}
override fun getItemId(position: Int): Long {
if (position == 0) return 0L
return ruleList[position - 1].id
}
private val updated = HashSet<RuleEntity>()
fun move(from: Int, to: Int) {
val first = ruleList[from - 1]
var previousOrder = first.userOrder
val (step, range) = if (from < to) Pair(1, from - 1 until to - 1) else Pair(
-1,
to downTo from - 1
)
for (i in range) {
val next = ruleList[i + step]
val order = next.userOrder
next.userOrder = previousOrder
previousOrder = order
ruleList[i] = next
updated.add(next)
}
first.userOrder = previousOrder
ruleList[to - 1] = first
updated.add(first)
notifyItemMoved(from, to)
}
fun commitMove() = runOnDefaultDispatcher {
if (updated.isNotEmpty()) {
SagerDatabase.rulesDao.updateRules(updated.toList())
updated.clear()
needReload()
}
}
fun remove(index: Int) {
ruleList.removeAt(index - 1)
notifyItemRemoved(index)
}
override fun undo(actions: List<Pair<Int, RuleEntity>>) {
for ((index, item) in actions) {
ruleList.add(index - 1, item)
notifyItemInserted(index)
}
}
override fun commit(actions: List<Pair<Int, RuleEntity>>) {
val rules = actions.map { it.second }
runOnDefaultDispatcher {
ProfileManager.deleteRules(rules)
}
}
override suspend fun onAdd(rule: RuleEntity) {
ruleListView.post {
ruleList.add(rule)
ruleAdapter.notifyItemInserted(ruleList.size)
needReload()
}
}
override suspend fun onUpdated(rule: RuleEntity) {
val index = ruleList.indexOfFirst { it.id == rule.id }
if (index == -1) return
ruleListView.post {
ruleList[index] = rule
ruleAdapter.notifyItemChanged(index + 1)
needReload()
}
}
override suspend fun onRemoved(ruleId: Long) {
val index = ruleList.indexOfFirst { it.id == ruleId }
if (index == -1) {
onMainDispatcher {
needReload()
}
} else ruleListView.post {
ruleList.removeAt(index)
ruleAdapter.notifyItemRemoved(index + 1)
needReload()
}
}
override suspend fun onCleared() {
ruleListView.post {
ruleList.clear()
ruleAdapter.notifyDataSetChanged()
needReload()
}
}
inner class DocumentHolder(binding: LayoutEmptyRouteBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind() {
itemView.setOnClickListener {
it.context.launchCustomTab("https://AntiNeko.github.io/cb4a-route/")
}
}
}
inner class RuleHolder(binding: LayoutRouteItemBinding) :
RecyclerView.ViewHolder(binding.root) {
lateinit var rule: RuleEntity
val profileName = binding.profileName
val profileType = binding.profileType
val routeOutbound = binding.routeOutbound
val editButton = binding.edit
val shareLayout = binding.share
val enableSwitch = binding.enable
fun bind(ruleEntity: RuleEntity) {
rule = ruleEntity
profileName.text = rule.displayName()
profileType.text = rule.mkSummary()
routeOutbound.text = rule.displayOutbound()
itemView.setOnClickListener {
enableSwitch.performClick()
}
enableSwitch.isChecked = rule.enabled
enableSwitch.setOnCheckedChangeListener { _, isChecked ->
runOnDefaultDispatcher {
rule.enabled = isChecked
SagerDatabase.rulesDao.updateRule(rule)
onMainDispatcher {
needReload()
}
}
}
editButton.setOnClickListener {
startActivity(Intent(it.context, RouteSettingsActivity::class.java).apply {
putExtra(RouteSettingsActivity.EXTRA_ROUTE_ID, rule.id)
})
}
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/RouteFragment.kt | 4091317823 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import android.view.View
import androidx.fragment.app.Fragment
import androidx.viewpager2.adapter.FragmentStateAdapter
import com.google.android.material.tabs.TabLayoutMediator
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.databinding.LayoutToolsBinding
import io.nekohasekai.sagernet.ktx.isExpert
class ToolsFragment : ToolbarFragment(R.layout.layout_tools) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
toolbar.setTitle(R.string.menu_tools)
val tools = mutableListOf<NamedFragment>()
tools.add(NetworkFragment())
tools.add(BackupFragment())
if (isExpert) tools.add(DebugFragment())
val binding = LayoutToolsBinding.bind(view)
binding.toolsPager.adapter = ToolsAdapter(tools)
TabLayoutMediator(binding.toolsTab, binding.toolsPager) { tab, position ->
tab.text = tools[position].name()
tab.view.setOnLongClickListener { // clear toast
true
}
}.attach()
}
inner class ToolsAdapter(val tools: List<Fragment>) : FragmentStateAdapter(this) {
override fun getItemCount() = tools.size
override fun createFragment(position: Int) = tools[position]
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/ToolsFragment.kt | 1095515311 |
package io.nekohasekai.sagernet.ui
import android.Manifest
import android.content.pm.PackageInfo
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.util.Log
import android.view.ViewGroup
import androidx.core.view.isVisible
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.databinding.LayoutVpnScanerBinding
import io.nekohasekai.sagernet.databinding.ViewVpnAppItemBinding
import io.nekohasekai.sagernet.ktx.toStringIterator
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import libcore.Libcore
import org.jf.dexlib2.dexbacked.DexBackedDexFile
import java.io.File
import java.util.zip.ZipFile
import kotlin.math.roundToInt
class VPNScanerActivity : ThemedActivity() {
private var binding: LayoutVpnScanerBinding? = null
private var adapter: Adapter? = null
private val appInfoList = mutableListOf<AppInfo>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setTitle(R.string.scan_vpn_app)
val binding = LayoutVpnScanerBinding.inflate(layoutInflater)
this.binding = binding
setContentView(binding.root)
supportActionBar?.setDisplayHomeAsUpEnabled(true)
binding.scanVPNResult.adapter = Adapter().also {
adapter = it
}
binding.scanVPNResult.layoutManager = LinearLayoutManager(this)
lifecycleScope.launch(Dispatchers.IO) {
scanVPN()
}
}
class VPNType(
val appType: String?,
val coreType: VPNCoreType?,
)
class VPNCoreType(
val coreType: String,
val corePath: String,
val goVersion: String
)
class AppInfo(
val packageInfo: PackageInfo,
val vpnType: VPNType,
)
inner class Adapter : RecyclerView.Adapter<Holder>() {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): Holder {
return Holder(ViewVpnAppItemBinding.inflate(layoutInflater, parent, false))
}
override fun getItemCount(): Int {
return appInfoList.size
}
override fun onBindViewHolder(holder: Holder, position: Int) {
holder.bind(appInfoList[position])
}
}
class Holder(
private val binding: ViewVpnAppItemBinding
) :
RecyclerView.ViewHolder(binding.root) {
fun bind(element: AppInfo) {
binding.appIcon.setImageDrawable(element.packageInfo.applicationInfo.loadIcon(binding.root.context.packageManager))
binding.appName.text =
element.packageInfo.applicationInfo.loadLabel(binding.root.context.packageManager)
binding.packageName.text = element.packageInfo.packageName
val appType = element.vpnType.appType
if (appType != null) {
binding.appTypeText.text = element.vpnType.appType
} else {
binding.appTypeText.setText(R.string.vpn_app_type_other)
}
val coreType = element.vpnType.coreType?.coreType
if (coreType != null) {
binding.coreTypeText.text = element.vpnType.coreType.coreType
} else {
binding.coreTypeText.setText(R.string.vpn_core_type_unknown)
}
val corePath = element.vpnType.coreType?.corePath.takeIf { !it.isNullOrBlank() }
if (corePath != null) {
binding.corePathLayout.isVisible = true
binding.corePathText.text = corePath
} else {
binding.corePathLayout.isVisible = false
}
val goVersion = element.vpnType.coreType?.goVersion.takeIf { !it.isNullOrBlank() }
if (goVersion != null) {
binding.goVersionLayout.isVisible = true
binding.goVersionText.text = goVersion
} else {
binding.goVersionLayout.isVisible = false
}
}
}
private suspend fun scanVPN() {
val adapter = adapter ?: return
val binding = binding ?: return
val flag =
PackageManager.GET_SERVICES or if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
PackageManager.MATCH_UNINSTALLED_PACKAGES
} else {
@Suppress("DEPRECATION")
PackageManager.GET_UNINSTALLED_PACKAGES
}
val installedPackages = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
packageManager.getInstalledPackages(PackageManager.PackageInfoFlags.of(flag.toLong()))
} else {
@Suppress("DEPRECATION")
packageManager.getInstalledPackages(flag)
}
val vpnAppList =
installedPackages.filter {
it.services?.any { it.permission == Manifest.permission.BIND_VPN_SERVICE } ?: false
}
for ((index, packageInfo) in vpnAppList.withIndex()) {
val appType = runCatching { getVPNAppType(packageInfo) }.getOrNull()
val coreType = runCatching { getVPNCoreType(packageInfo) }.getOrNull()
appInfoList.add(AppInfo(packageInfo, VPNType(appType, coreType)))
withContext(Dispatchers.Main) {
adapter.notifyItemInserted(index)
binding.scanVPNResult.scrollToPosition(index)
binding.scanVPNProgress.setProgressCompat(
(((index + 1).toFloat() / vpnAppList.size.toFloat()) * 100).roundToInt(),
true
)
}
System.gc()
}
withContext(Dispatchers.Main) {
binding.scanVPNProgress.isVisible = false
}
}
companion object {
private val v2rayNGClasses = listOf(
"com.v2ray.ang",
".dto.V2rayConfig",
".service.V2RayVpnService",
)
private val clashForAndroidClasses = listOf(
"com.github.kr328.clash",
".core.Clash",
".service.TunService",
)
private val sfaClasses = listOf(
"io.nekohasekai.sfa"
)
private val legacySagerNetClasses = listOf(
"io.nekohasekai.sagernet",
".fmt.ConfigBuilder"
)
private val shadowsocksAndroidClasses = listOf(
"com.github.shadowsocks",
".bg.VpnService",
"GuardedProcessPool"
)
}
private fun getVPNAppType(packageInfo: PackageInfo): String? {
ZipFile(File(packageInfo.applicationInfo.publicSourceDir)).use { packageFile ->
for (packageEntry in packageFile.entries()) {
if (!(packageEntry.name.startsWith("classes") && packageEntry.name.endsWith(
".dex"
))
) {
continue
}
if (packageEntry.size > 15000000) {
continue
}
val input = packageFile.getInputStream(packageEntry).buffered()
val dexFile = try {
DexBackedDexFile.fromInputStream(null, input)
} catch (e: Exception) {
Log.e("VPNScanActivity", "Failed to read dex file", e)
continue
}
for (clazz in dexFile.classes) {
val clazzName = clazz.type.substring(1, clazz.type.length - 1)
.replace("/", ".")
.replace("$", ".")
for (v2rayNGClass in v2rayNGClasses) {
if (clazzName.contains(v2rayNGClass)) {
return "V2RayNG"
}
}
for (clashForAndroidClass in clashForAndroidClasses) {
if (clazzName.contains(clashForAndroidClass)) {
return "ClashForAndroid"
}
}
for (sfaClass in sfaClasses) {
if (clazzName.contains(sfaClass)) {
return "sing-box"
}
}
for (legacySagerNetClass in legacySagerNetClasses) {
if (clazzName.contains(legacySagerNetClass)) {
return "LegacySagerNet"
}
}
for (shadowsocksAndroidClass in shadowsocksAndroidClasses) {
if (clazzName.contains(shadowsocksAndroidClass)) {
return "shadowsocks-android"
}
}
}
}
return null
}
}
private fun getVPNCoreType(packageInfo: PackageInfo): VPNCoreType? {
val packageFiles = mutableListOf(packageInfo.applicationInfo.publicSourceDir)
packageInfo.applicationInfo.splitPublicSourceDirs?.also {
packageFiles.addAll(it)
}
val vpnType = try {
Libcore.readAndroidVPNType(packageFiles.toStringIterator())
} catch (ignored: Exception) {
return null
}
return VPNCoreType(vpnType.coreType, vpnType.corePath, vpnType.goVersion)
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/VPNScanerActivity.kt | 1091614776 |
package io.nekohasekai.sagernet.ui
import android.annotation.SuppressLint
import android.graphics.Color
import android.os.Build
import android.os.Bundle
import android.text.SpannableString
import android.text.Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
import android.text.style.ForegroundColorSpan
import android.view.MenuItem
import android.view.View
import android.widget.ScrollView
import androidx.appcompat.widget.Toolbar
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.databinding.LayoutLogcatBinding
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.readableMessage
import io.nekohasekai.sagernet.ktx.runOnDefaultDispatcher
import io.nekohasekai.sagernet.ktx.snackbar
import libcore.Libcore
import moe.matsuri.nb4a.utils.SendLog
class LogcatFragment : ToolbarFragment(R.layout.layout_logcat),
Toolbar.OnMenuItemClickListener {
lateinit var binding: LayoutLogcatBinding
@SuppressLint("RestrictedApi", "WrongConstant")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
toolbar.setTitle(R.string.menu_log)
toolbar.inflateMenu(R.menu.logcat_menu)
toolbar.setOnMenuItemClickListener(this)
binding = LayoutLogcatBinding.bind(view)
if (Build.VERSION.SDK_INT >= 23) {
binding.textview.breakStrategy = 0 // simple
}
reloadSession()
// TODO new logcat
}
private fun getColorForLine(line: String): ForegroundColorSpan {
var color = ForegroundColorSpan(Color.GRAY)
when {
line.contains(" INFO[") || line.contains(" [Info]") -> {
color = ForegroundColorSpan((0xFF86C166).toInt())
}
line.contains(" ERROR[") || line.contains(" [Error]") -> {
color = ForegroundColorSpan(Color.RED)
}
line.contains(" WARN[") || line.contains(" [Warning]") -> {
color = ForegroundColorSpan(Color.RED)
}
}
return color
}
private fun reloadSession() {
val span = SpannableString(
String(SendLog.getNekoLog(50 * 1024))
)
var offset = 0
for (line in span.lines()) {
val color = getColorForLine(line)
span.setSpan(
color, offset, offset + line.length, SPAN_EXCLUSIVE_EXCLUSIVE
)
offset += line.length + 1
}
binding.textview.text = span
binding.scroolview.post {
binding.scroolview.fullScroll(ScrollView.FOCUS_DOWN)
}
}
override fun onMenuItemClick(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_clear_logcat -> {
runOnDefaultDispatcher {
try {
Libcore.nekoLogClear()
Runtime.getRuntime().exec("/system/bin/logcat -c")
} catch (e: Exception) {
onMainDispatcher {
snackbar(e.readableMessage).show()
}
return@runOnDefaultDispatcher
}
onMainDispatcher {
binding.textview.text = ""
}
}
}
R.id.action_send_logcat -> {
val context = requireContext()
runOnDefaultDispatcher {
SendLog.sendLog(context, "husi")
}
}
R.id.action_refresh -> {
reloadSession()
}
}
return true
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/LogcatFragment.kt | 2724534063 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.os.Build
import android.os.Bundle
import android.view.View
import android.view.inputmethod.EditorInfo
import android.widget.EditText
import androidx.core.app.ActivityCompat
import androidx.preference.*
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.preference.EditTextPreferenceModifiers
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.utils.Theme
import io.nekohasekai.sagernet.widget.AppListPreference
import moe.matsuri.nb4a.Protocols
import moe.matsuri.nb4a.ui.ColorPickerPreference
import moe.matsuri.nb4a.ui.LongClickListPreference
import moe.matsuri.nb4a.ui.MTUPreference
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class SettingsPreferenceFragment : PreferenceFragmentCompat() {
private lateinit var isProxyApps: SwitchPreference
private lateinit var nekoPlugins: AppListPreference
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
listView.layoutManager = FixedLinearLayoutManager(listView)
}
private val reloadListener = Preference.OnPreferenceChangeListener { _, _ ->
needReload()
true
}
override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
preferenceManager.preferenceDataStore = DataStore.configurationStore
DataStore.initGlobal()
addPreferencesFromResource(R.xml.global_preferences)
DataStore.routePackages = DataStore.nekoPlugins
nekoPlugins = findPreference(Key.NEKO_PLUGIN_MANAGED)!!
nekoPlugins.setOnPreferenceClickListener {
// borrow from route app settings
startActivity(Intent(
context, AppListActivity::class.java
).apply { putExtra(Key.NEKO_PLUGIN_MANAGED, true) })
true
}
val appTheme = findPreference<ColorPickerPreference>(Key.APP_THEME)!!
appTheme.setOnPreferenceChangeListener { _, newTheme ->
if (DataStore.serviceState.started) {
SagerNet.reloadService()
}
val theme = Theme.getTheme(newTheme as Int)
app.setTheme(theme)
requireActivity().apply {
setTheme(theme)
ActivityCompat.recreate(this)
}
true
}
val nightTheme = findPreference<SimpleMenuPreference>(Key.NIGHT_THEME)!!
nightTheme.setOnPreferenceChangeListener { _, newTheme ->
Theme.currentNightMode = (newTheme as String).toInt()
Theme.applyNightTheme()
true
}
val mixedPort = findPreference<EditTextPreference>(Key.MIXED_PORT)!!
val serviceMode = findPreference<Preference>(Key.SERVICE_MODE)!!
val allowAccess = findPreference<Preference>(Key.ALLOW_ACCESS)!!
val appendHttpProxy = findPreference<SwitchPreference>(Key.APPEND_HTTP_PROXY)!!
val portLocalDns = findPreference<EditTextPreference>(Key.LOCAL_DNS_PORT)!!
val showDirectSpeed = findPreference<SwitchPreference>(Key.SHOW_DIRECT_SPEED)!!
val ipv6Mode = findPreference<Preference>(Key.IPV6_MODE)!!
val trafficSniffing = findPreference<Preference>(Key.TRAFFIC_SNIFFING)!!
val muxConcurrency = findPreference<EditTextPreference>(Key.MUX_CONCURRENCY)!!
val tcpKeepAliveInterval = findPreference<EditTextPreference>(Key.TCP_KEEP_ALIVE_INTERVAL)!!
tcpKeepAliveInterval.isVisible = false
val bypassLan = findPreference<SwitchPreference>(Key.BYPASS_LAN)!!
val bypassLanInCore = findPreference<SwitchPreference>(Key.BYPASS_LAN_IN_CORE)!!
val inboundUsername = findPreference<EditTextPreference>(Key.INBOUND_USERNAME)!!
val inboundPassword = findPreference<EditTextPreference>(Key.INBOUND_PASSWORD)!!
val remoteDns = findPreference<EditTextPreference>(Key.REMOTE_DNS)!!
val directDns = findPreference<EditTextPreference>(Key.DIRECT_DNS)!!
val underlyingDns = findPreference<EditTextPreference>(Key.UNDERLYING_DNS)!!
val enableDnsRouting = findPreference<SwitchPreference>(Key.ENABLE_DNS_ROUTING)!!
val enableFakeDns = findPreference<SwitchPreference>(Key.ENABLE_FAKEDNS)!!
val logLevel = findPreference<LongClickListPreference>(Key.LOG_LEVEL)!!
val mtu = findPreference<MTUPreference>(Key.MTU)!!
logLevel.dialogLayoutResource = R.layout.layout_loglevel_help
logLevel.setOnPreferenceChangeListener { _, _ ->
needRestart()
true
}
logLevel.setOnLongClickListener {
if (context == null) return@setOnLongClickListener true
val view = EditText(context).apply {
inputType = EditorInfo.TYPE_CLASS_NUMBER
var size = DataStore.logBufSize
if (size == 0) size = 50
setText(size.toString())
}
MaterialAlertDialogBuilder(requireContext()).setTitle("Log buffer size (kb)")
.setView(view)
.setPositiveButton(android.R.string.ok) { _, _ ->
DataStore.logBufSize = view.text.toString().toInt()
if (DataStore.logBufSize <= 0) DataStore.logBufSize = 50
needRestart()
}
.setNegativeButton(android.R.string.cancel, null)
.show()
true
}
val muxProtocols = findPreference<MultiSelectListPreference>(Key.MUX_PROTOCOLS)!!
muxProtocols.apply {
val e = Protocols.getCanMuxList().toTypedArray()
entries = e
entryValues = e
}
portLocalDns.setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
muxConcurrency.setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
mixedPort.setOnBindEditTextListener(EditTextPreferenceModifiers.Port)
val metedNetwork = findPreference<Preference>(Key.METERED_NETWORK)!!
if (Build.VERSION.SDK_INT < 28) {
metedNetwork.remove()
}
isProxyApps = findPreference(Key.PROXY_APPS)!!
isProxyApps.setOnPreferenceChangeListener { _, newValue ->
startActivity(Intent(activity, AppManagerActivity::class.java))
if (newValue as Boolean) DataStore.dirty = true
newValue
}
val profileTrafficStatistics =
findPreference<SwitchPreference>(Key.PROFILE_TRAFFIC_STATISTICS)!!
val speedInterval = findPreference<SimpleMenuPreference>(Key.SPEED_INTERVAL)!!
profileTrafficStatistics.isEnabled = speedInterval.value.toString() != "0"
speedInterval.setOnPreferenceChangeListener { _, newValue ->
profileTrafficStatistics.isEnabled = newValue.toString() != "0"
needReload()
true
}
serviceMode.setOnPreferenceChangeListener { _, _ ->
if (DataStore.serviceState.started) SagerNet.stopService()
true
}
val tunImplementation = findPreference<SimpleMenuPreference>(Key.TUN_IMPLEMENTATION)!!
val resolveDestination = findPreference<SwitchPreference>(Key.RESOLVE_DESTINATION)!!
val acquireWakeLock = findPreference<SwitchPreference>(Key.ACQUIRE_WAKE_LOCK)!!
val clashAPIListen = reloadListener
mixedPort.onPreferenceChangeListener = reloadListener
appendHttpProxy.onPreferenceChangeListener = reloadListener
showDirectSpeed.onPreferenceChangeListener = reloadListener
trafficSniffing.onPreferenceChangeListener = reloadListener
muxConcurrency.onPreferenceChangeListener = reloadListener
tcpKeepAliveInterval.onPreferenceChangeListener = reloadListener
bypassLan.onPreferenceChangeListener = reloadListener
bypassLanInCore.onPreferenceChangeListener = reloadListener
inboundUsername.onPreferenceChangeListener = reloadListener
inboundPassword.onPreferenceChangeListener = reloadListener
mtu.onPreferenceChangeListener = reloadListener
enableFakeDns.onPreferenceChangeListener = reloadListener
remoteDns.onPreferenceChangeListener = reloadListener
directDns.onPreferenceChangeListener = reloadListener
underlyingDns.onPreferenceChangeListener = reloadListener
enableDnsRouting.onPreferenceChangeListener = reloadListener
portLocalDns.onPreferenceChangeListener = reloadListener
ipv6Mode.onPreferenceChangeListener = reloadListener
allowAccess.onPreferenceChangeListener = reloadListener
resolveDestination.onPreferenceChangeListener = reloadListener
tunImplementation.onPreferenceChangeListener = reloadListener
acquireWakeLock.onPreferenceChangeListener = reloadListener
}
override fun onResume() {
super.onResume()
if (::isProxyApps.isInitialized) {
isProxyApps.isChecked = DataStore.proxyApps
}
if (::nekoPlugins.isInitialized) {
nekoPlugins.postUpdate()
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/SettingsPreferenceFragment.kt | 3895589593 |
package io.nekohasekai.sagernet.ui
import android.content.Intent
import android.os.Bundle
import android.view.View
import androidx.appcompat.app.AlertDialog
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProfileManager
import io.nekohasekai.sagernet.databinding.LayoutNetworkBinding
import io.nekohasekai.sagernet.databinding.LayoutProgressBinding
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.utils.Cloudflare
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import kotlinx.coroutines.runBlocking
class NetworkFragment : NamedFragment(R.layout.layout_network) {
override fun name0() = app.getString(R.string.tools_network)
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val binding = LayoutNetworkBinding.bind(view)
binding.stunTest.setOnClickListener {
startActivity(Intent(requireContext(), StunActivity::class.java))
}
//Markwon.create(requireContext())
// .setMarkdown(binding.wrapLicense, getString(R.string.warp_license))
binding.warpGenerate.setOnClickListener {
runBlocking {
generateWarpConfiguration()
}
}
binding.getCert.setOnClickListener {
startActivity(Intent(requireContext(), GetCertActivity::class.java))
}
binding.scanVPN.setOnClickListener {
startActivity(Intent(requireContext(), VPNScanerActivity::class.java))
}
}
suspend fun generateWarpConfiguration() {
val activity = requireActivity() as MainActivity
val binding = LayoutProgressBinding.inflate(layoutInflater).apply {
content.setText(R.string.generating)
}
var job: Job? = null
val dialog = AlertDialog.Builder(requireContext())
.setView(binding.root)
.setCancelable(false)
.setNegativeButton(android.R.string.cancel) { _, _ ->
job?.cancel()
}
.show()
job = runOnDefaultDispatcher {
try {
val bean = Cloudflare.makeWireGuardConfiguration()
if (isActive) {
val groupId = DataStore.selectedGroupForImport()
if (DataStore.selectedGroup != groupId) {
DataStore.selectedGroup = groupId
}
onMainDispatcher {
activity.displayFragmentWithId(R.id.nav_configuration)
}
delay(1000L)
onMainDispatcher {
dialog.dismiss()
}
ProfileManager.createProfile(groupId, bean)
}
} catch (e: Exception) {
Logs.w(e)
onMainDispatcher {
if (isActive) {
dialog.dismiss()
activity.snackbar(e.readableMessage).show()
}
}
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/NetworkFragment.kt | 1066469849 |
package io.nekohasekai.sagernet.ui
import android.os.Bundle
import android.provider.OpenableColumns
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import androidx.activity.result.contract.ActivityResultContracts
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.RecyclerView
import com.google.android.material.progressindicator.LinearProgressIndicator
import com.google.android.material.snackbar.Snackbar
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.databinding.LayoutAssetItemBinding
import io.nekohasekai.sagernet.databinding.LayoutAssetsBinding
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.widget.UndoSnackbarManager
import libcore.Libcore
import java.io.File
import java.io.FileWriter
import java.time.LocalDate
import java.time.format.DateTimeFormatter
class AssetsActivity : ThemedActivity() {
lateinit var adapter: AssetAdapter
lateinit var layout: LayoutAssetsBinding
lateinit var undoManager: UndoSnackbarManager<File>
lateinit var updating: LinearProgressIndicator
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val binding = LayoutAssetsBinding.inflate(layoutInflater)
layout = binding
setContentView(binding.root)
updating = findViewById(R.id.action_updating)
setSupportActionBar(findViewById(R.id.toolbar))
supportActionBar?.apply {
setTitle(R.string.route_assets)
setDisplayHomeAsUpEnabled(true)
setHomeAsUpIndicator(R.drawable.ic_navigation_close)
}
binding.recyclerView.layoutManager = FixedLinearLayoutManager(binding.recyclerView)
adapter = AssetAdapter()
binding.recyclerView.adapter = adapter
binding.refreshLayout.setOnRefreshListener {
adapter.reloadAssets()
binding.refreshLayout.isRefreshing = false
}
binding.refreshLayout.setColorSchemeColors(getColorAttr(R.attr.primaryOrTextPrimary))
undoManager = UndoSnackbarManager(this, adapter)
ItemTouchHelper(object : ItemTouchHelper.SimpleCallback(
0, ItemTouchHelper.START
) {
override fun getSwipeDirs(
recyclerView: RecyclerView, viewHolder: RecyclerView.ViewHolder
): Int {
val index = viewHolder.bindingAdapterPosition
if (index < 2) return 0
return super.getSwipeDirs(recyclerView, viewHolder)
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
val index = viewHolder.bindingAdapterPosition
adapter.remove(index)
undoManager.remove(index to (viewHolder as AssetHolder).file)
}
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
target: RecyclerView.ViewHolder
) = false
}).attachToRecyclerView(binding.recyclerView)
}
override fun snackbarInternal(text: CharSequence): Snackbar {
return Snackbar.make(layout.coordinator, text, Snackbar.LENGTH_LONG)
}
// val assetNames = listOf("geoip", "geosite")
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.asset_menu, menu)
return true
}
private val importFile =
registerForActivityResult(ActivityResultContracts.GetContent()) { file ->
if (file != null) {
val fileName = contentResolver.query(file, null, null, null, null)?.use { cursor ->
cursor.moveToFirst()
cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME)
.let(cursor::getString)
}?.takeIf { it.isNotBlank() } ?: file.pathSegments.last().substringAfterLast('/')
.substringAfter(':')
if (fileName.endsWith(".zip")) {
alert(getString(R.string.route_not_asset, fileName)).show()
return@registerForActivityResult
}
val filesDir = getExternalFilesDir(null) ?: filesDir
runOnDefaultDispatcher {
val outFile = File(filesDir, fileName).apply {
parentFile?.mkdirs()
}
contentResolver.openInputStream(file)?.use(outFile.outputStream())
File(outFile.parentFile, outFile.nameWithoutExtension + ".version.txt").apply {
if (isFile) delete()
createNewFile()
val fw = FileWriter(this)
fw.write("Custom")
fw.close()
}
adapter.reloadAssets()
}
}
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_import_file -> {
startFilesForResult(importFile, "*/*")
return true
}
R.id.action_update_all -> {
runOnDefaultDispatcher {
updateAsset()
}
return true
}
}
return false
}
inner class AssetAdapter : RecyclerView.Adapter<AssetHolder>(),
UndoSnackbarManager.Interface<File> {
private val assets = ArrayList<File>()
init {
reloadAssets()
}
fun reloadAssets() {
val filesDir = getExternalFilesDir(null) ?: filesDir
val geoDir = File(filesDir, "geo")
if (!geoDir.exists()) {
geoDir.mkdirs()
}
// val files = filesDir.listFiles()
// ?.filter { it.isFile && it.name.endsWith("version.txt") }
assets.clear()
assets.add(File(filesDir, "geoip.version.txt"))
assets.add(File(filesDir, "geosite.version.txt"))
// if (files != null) assets.addAll(files)
updating.visibility = View.GONE
layout.refreshLayout.post {
notifyDataSetChanged()
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): AssetHolder {
return AssetHolder(LayoutAssetItemBinding.inflate(layoutInflater, parent, false))
}
override fun onBindViewHolder(holder: AssetHolder, position: Int) {
holder.bind(assets[position])
}
override fun getItemCount(): Int {
return assets.size
}
fun remove(index: Int) {
assets.removeAt(index)
notifyItemRemoved(index)
}
override fun undo(actions: List<Pair<Int, File>>) {
for ((index, item) in actions) {
assets.add(index, item)
notifyItemInserted(index)
}
}
override fun commit(actions: List<Pair<Int, File>>) {
val groups = actions.map { it.second }.toTypedArray()
runOnDefaultDispatcher {
groups.forEach { it.deleteRecursively() }
}
}
}
// val updating = AtomicInteger()
inner class AssetHolder(val binding: LayoutAssetItemBinding) :
RecyclerView.ViewHolder(binding.root) {
lateinit var file: File
fun bind(file: File) {
this.file = file
binding.assetName.text = file.name.removeSuffix(".version.txt")
val localVersion = if (file.isFile) {
file.readText().trim()
} else {
"Unknown"
}
binding.assetStatus.text = getString(R.string.route_asset_status, localVersion)
}
}
private suspend fun updateAsset() {
val filesDir = getExternalFilesDir(null) ?: filesDir
val repos: List<String> = when (DataStore.rulesProvider) {
0 -> listOf("SagerNet/sing-geoip", "SagerNet/sing-geosite")
1 -> listOf("xchacha20-poly1305/sing-geoip", "xchacha20-poly1305/sing-geosite")
2 -> listOf("Chocolate4U/Iran-sing-box-rules")
else -> listOf("SagerNet/sing-geoip", "SagerNet/sing-geosite")
}
onMainDispatcher {
updating.visibility = View.VISIBLE
}
val geoDir = File(filesDir, "geo")
var cacheFiles: Array<File> = arrayOf()
for ((list, repo) in repos.withIndex()) {
val client = Libcore.newHttpClient().apply {
modernTLS()
keepAlive()
trySocks5(DataStore.mixedPort)
useCazilla(DataStore.enabledCazilla)
}
try {
// https://codeload.github.com/SagerNet/sing-geosite/zip/refs/heads/rule-set
val response = client.newRequest().apply {
setURL("https://codeload.github.com/$repo/zip/refs/heads/rule-set")
}.execute()
val cacheFile = File(filesDir.parentFile, filesDir.name + list + ".tmp")
cacheFile.parentFile?.mkdirs()
response.writeTo(cacheFile.canonicalPath)
cacheFiles += cacheFile
adapter.reloadAssets()
} catch (e: Exception) {
onMainDispatcher {
e.message?.let { snackbar(it).show() }
}
} finally {
client.close()
}
}
for (cacheFile in cacheFiles) {
Libcore.unzipWithoutDir(cacheFile.absolutePath, geoDir.absolutePath)
cacheFile.delete()
}
onMainDispatcher {
snackbar(R.string.route_asset_updated).show()
updating.visibility = View.GONE
}
val versionFileList: List<File> = listOf(
File(filesDir, "geoip.version.txt"),
File(filesDir, "geosite.version.txt")
)
for (versionFile in versionFileList) {
versionFile.writeText(
LocalDate.now()
.format(
DateTimeFormatter
.ofPattern("yyyyMMdd")
)
)
}
adapter.reloadAssets()
}
override fun onSupportNavigateUp(): Boolean {
finish()
return true
}
override fun onBackPressed() {
finish()
}
override fun onResume() {
super.onResume()
if (::adapter.isInitialized) {
adapter.reloadAssets()
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ui/AssetsActivity.kt | 3127452537 |
package io.nekohasekai.sagernet.ui
import android.annotation.SuppressLint
import android.os.Bundle
import android.text.InputType
import android.view.MenuItem
import android.view.View
import android.webkit.*
import android.widget.EditText
import androidx.appcompat.widget.Toolbar
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.BuildConfig
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.databinding.LayoutWebviewBinding
import moe.matsuri.nb4a.utils.WebViewUtil
// Fragment必须有一个无参public的构造函数，否则在数据恢复的时候，会报crash
class WebviewFragment : ToolbarFragment(R.layout.layout_webview), Toolbar.OnMenuItemClickListener {
lateinit var mWebView: WebView
@SuppressLint("SetJavaScriptEnabled")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
// layout
toolbar.setTitle(R.string.menu_dashboard)
toolbar.inflateMenu(R.menu.dash_menu)
toolbar.setOnMenuItemClickListener(this)
val binding = LayoutWebviewBinding.bind(view)
// webview
WebView.setWebContentsDebuggingEnabled(BuildConfig.DEBUG)
mWebView = binding.webview
mWebView.settings.domStorageEnabled = true
mWebView.settings.javaScriptEnabled = true
mWebView.webViewClient = object : WebViewClient() {
override fun onReceivedError(
view: WebView?, request: WebResourceRequest?, error: WebResourceError?
) {
WebViewUtil.onReceivedError(view, request, error)
}
override fun onPageFinished(view: WebView?, url: String?) {
super.onPageFinished(view, url)
}
}
mWebView.loadUrl(DataStore.dashURL)
}
@SuppressLint("CheckResult")
override fun onMenuItemClick(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_set_url -> {
val view = EditText(context).apply {
inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_URI
setText(DataStore.dashURL)
}
MaterialAlertDialogBuilder(requireContext()).setTitle(R.string.set_panel_url)
.setView(view)
.setPositiveButton(android.R.string.ok) { _, _ ->
DataStore.dashURL = view.text.toString()
mWebView.loadUrl(DataStore.dashURL)
}
.setNegativeButton(android.R.string.cancel, null)
.show()
}
R.id.close -> {
mWebView.onPause()
mWebView.removeAllViews()
mWebView.destroy()
}
}
return true
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ui/WebviewFragment.kt | 2235866192 |
package io.nekohasekai.sagernet.database
import androidx.room.*
import com.esotericsoftware.kryo.io.ByteBufferInput
import com.esotericsoftware.kryo.io.ByteBufferOutput
import io.nekohasekai.sagernet.GroupOrder
import io.nekohasekai.sagernet.GroupType
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.fmt.Serializable
import io.nekohasekai.sagernet.ktx.app
import io.nekohasekai.sagernet.ktx.applyDefaultValues
@Entity(tableName = "proxy_groups")
data class ProxyGroup(
@PrimaryKey(autoGenerate = true) var id: Long = 0L,
var userOrder: Long = 0L,
var ungrouped: Boolean = false,
var name: String? = null,
var type: Int = GroupType.BASIC,
var subscription: SubscriptionBean? = null,
var order: Int = GroupOrder.ORIGIN,
var isSelector: Boolean = false,
var frontProxy: Long = -1L,
var landingProxy: Long = -1L
) : Serializable() {
@Transient
var export = false
override fun initializeDefaultValues() {
subscription?.applyDefaultValues()
}
override fun serializeToBuffer(output: ByteBufferOutput) {
if (export) {
output.writeInt(0)
output.writeString(name)
output.writeInt(type)
val subscription = subscription!!
subscription.serializeForShare(output)
} else {
output.writeInt(0)
output.writeLong(id)
output.writeLong(userOrder)
output.writeBoolean(ungrouped)
output.writeString(name)
output.writeInt(type)
if (type == GroupType.SUBSCRIPTION) {
subscription?.serializeToBuffer(output)
}
output.writeInt(order)
}
}
override fun deserializeFromBuffer(input: ByteBufferInput) {
if (export) {
val version = input.readInt()
name = input.readString()
type = input.readInt()
val subscription = SubscriptionBean()
this.subscription = subscription
subscription.deserializeFromShare(input)
} else {
val version = input.readInt()
id = input.readLong()
userOrder = input.readLong()
ungrouped = input.readBoolean()
name = input.readString()
type = input.readInt()
if (type == GroupType.SUBSCRIPTION) {
val subscription = SubscriptionBean()
this.subscription = subscription
subscription.deserializeFromBuffer(input)
}
order = input.readInt()
}
}
fun displayName(): String {
return name.takeIf { !it.isNullOrBlank() } ?: app.getString(R.string.group_default)
}
@androidx.room.Dao
interface Dao {
@Query("SELECT * FROM proxy_groups ORDER BY userOrder")
fun allGroups(): List<ProxyGroup>
@Query("SELECT * FROM proxy_groups WHERE type = ${GroupType.SUBSCRIPTION}")
suspend fun subscriptions(): List<ProxyGroup>
@Query("SELECT MAX(userOrder) + 1 FROM proxy_groups")
fun nextOrder(): Long?
@Query("SELECT * FROM proxy_groups WHERE id = :groupId")
fun getById(groupId: Long): ProxyGroup?
@Query("DELETE FROM proxy_groups WHERE id = :groupId")
fun deleteById(groupId: Long): Int
@Delete
fun deleteGroup(group: ProxyGroup)
@Delete
fun deleteGroup(groupList: List<ProxyGroup>)
@Insert
fun createGroup(group: ProxyGroup): Long
@Update
fun updateGroup(group: ProxyGroup)
@Query("DELETE FROM proxy_groups")
fun reset()
@Insert
fun insert(groupList: List<ProxyGroup>)
}
companion object {
@JvmField
val CREATOR = object : Serializable.CREATOR<ProxyGroup>() {
override fun newInstance(): ProxyGroup {
return ProxyGroup()
}
override fun newArray(size: Int): Array<ProxyGroup?> {
return arrayOfNulls(size)
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/database/ProxyGroup.kt | 2633936753 |
package io.nekohasekai.sagernet.database
import android.os.Binder
import androidx.preference.PreferenceDataStore
import io.nekohasekai.sagernet.*
import io.nekohasekai.sagernet.bg.BaseService
import io.nekohasekai.sagernet.bg.VpnService
import io.nekohasekai.sagernet.database.preference.OnPreferenceDataStoreChangeListener
import io.nekohasekai.sagernet.database.preference.PublicDatabase
import io.nekohasekai.sagernet.database.preference.RoomPreferenceDataStore
import io.nekohasekai.sagernet.ktx.*
import moe.matsuri.nb4a.TempDatabase
object DataStore : OnPreferenceDataStoreChangeListener {
// share service state in main & bg process
@Volatile
var serviceState = BaseService.State.Idle
val configurationStore = RoomPreferenceDataStore(PublicDatabase.kvPairDao)
val profileCacheStore = RoomPreferenceDataStore(TempDatabase.profileCacheDao)
// last used, but may not be running
var currentProfile by configurationStore.long(Key.PROFILE_CURRENT)
var selectedProxy by configurationStore.long(Key.PROFILE_ID)
var selectedGroup by configurationStore.long(Key.PROFILE_GROUP) { currentGroupId() } // "ungrouped" group id = 1
// only in bg process
var vpnService: VpnService? = null
var baseService: BaseService.Interface? = null
fun currentGroupId(): Long {
val currentSelected = configurationStore.getLong(Key.PROFILE_GROUP, -1)
if (currentSelected > 0L) return currentSelected
val groups = SagerDatabase.groupDao.allGroups()
if (groups.isNotEmpty()) {
val groupId = groups[0].id
selectedGroup = groupId
return groupId
}
val groupId = SagerDatabase.groupDao.createGroup(ProxyGroup(ungrouped = true))
selectedGroup = groupId
return groupId
}
fun currentGroup(): ProxyGroup {
var group: ProxyGroup? = null
val currentSelected = configurationStore.getLong(Key.PROFILE_GROUP, -1)
if (currentSelected > 0L) {
group = SagerDatabase.groupDao.getById(currentSelected)
}
if (group != null) return group
val groups = SagerDatabase.groupDao.allGroups()
if (groups.isEmpty()) {
group = ProxyGroup(ungrouped = true).apply {
id = SagerDatabase.groupDao.createGroup(this)
}
} else {
group = groups[0]
}
selectedGroup = group.id
return group
}
fun selectedGroupForImport(): Long {
val current = currentGroup()
if (current.type == GroupType.BASIC) return current.id
val groups = SagerDatabase.groupDao.allGroups()
return groups.find { it.type == GroupType.BASIC }!!.id
}
var nekoPlugins by configurationStore.string(Key.NEKO_PLUGIN_MANAGED)
var appTLSVersion by configurationStore.string(Key.APP_TLS_VERSION)
var clashAPIListen by configurationStore.string(Key.CLASH_API_LISTEN)
var showBottomBar by configurationStore.boolean(Key.SHOW_BOTTOM_BAR)
var allowInsecureOnRequest by configurationStore.boolean(Key.ALLOW_INSECURE_ON_REQUEST)
//
var isExpert by configurationStore.boolean(Key.APP_EXPERT)
var appTheme by configurationStore.int(Key.APP_THEME)
var nightTheme by configurationStore.stringToInt(Key.NIGHT_THEME)
var serviceMode by configurationStore.string(Key.SERVICE_MODE) { Key.MODE_VPN }
var trafficSniffing by configurationStore.stringToInt(Key.TRAFFIC_SNIFFING) { 1 }
var resolveDestination by configurationStore.boolean(Key.RESOLVE_DESTINATION)
// var tcpKeepAliveInterval by configurationStore.stringToInt(Key.TCP_KEEP_ALIVE_INTERVAL) { 15 }
var mtu by configurationStore.stringToInt(Key.MTU) { 9000 }
var bypassLan by configurationStore.boolean(Key.BYPASS_LAN)
var bypassLanInCore by configurationStore.boolean(Key.BYPASS_LAN_IN_CORE)
var inboundUsername by configurationStore.string(Key.INBOUND_USERNAME) { "" }
var inboundPassword by configurationStore.string(Key.INBOUND_PASSWORD) { "" }
var allowAccess by configurationStore.boolean(Key.ALLOW_ACCESS)
var speedInterval by configurationStore.stringToInt(Key.SPEED_INTERVAL)
var showGroupInNotification by configurationStore.boolean("showGroupInNotification")
var remoteDns by configurationStore.string(Key.REMOTE_DNS) { "https://dns.google/dns-query" }
var directDns by configurationStore.string(Key.DIRECT_DNS) { "local" }
var underlyingDns by configurationStore.string(Key.UNDERLYING_DNS) { "local" }
var enableDnsRouting by configurationStore.boolean(Key.ENABLE_DNS_ROUTING) { true }
var enableFakeDns by configurationStore.boolean(Key.ENABLE_FAKEDNS)
var rulesProvider by configurationStore.stringToInt(Key.RULES_PROVIDER)
var logLevel by configurationStore.stringToInt(Key.LOG_LEVEL)
var logBufSize by configurationStore.int(Key.LOG_BUF_SIZE) { 0 }
var acquireWakeLock by configurationStore.boolean(Key.ACQUIRE_WAKE_LOCK)
// hopefully hashCode = mHandle doesn't change, currently this is true from KitKat to Nougat
private val userIndex by lazy { Binder.getCallingUserHandle().hashCode() }
var mixedPort: Int
get() = getLocalPort(Key.MIXED_PORT, 2080)
set(value) = saveLocalPort(Key.MIXED_PORT, value)
var localDNSPort: Int
get() = getLocalPort(Key.LOCAL_DNS_PORT, 6450)
set(value) {
saveLocalPort(Key.LOCAL_DNS_PORT, value)
}
fun initGlobal() {
if (configurationStore.getString(Key.MIXED_PORT) == null) {
mixedPort = mixedPort
}
if (configurationStore.getString(Key.LOCAL_DNS_PORT) == null) {
localDNSPort = localDNSPort
}
}
private fun getLocalPort(key: String, default: Int): Int {
return parsePort(configurationStore.getString(key), default + userIndex)
}
private fun saveLocalPort(key: String, value: Int) {
configurationStore.putString(key, "$value")
}
var ipv6Mode by configurationStore.stringToInt(Key.IPV6_MODE) { IPv6Mode.DISABLE }
var meteredNetwork by configurationStore.boolean(Key.METERED_NETWORK)
var proxyApps by configurationStore.boolean(Key.PROXY_APPS)
var bypass by configurationStore.boolean(Key.BYPASS_MODE) { true }
var individual by configurationStore.string(Key.INDIVIDUAL)
var showDirectSpeed by configurationStore.boolean(Key.SHOW_DIRECT_SPEED) { true }
val persistAcrossReboot by configurationStore.boolean(Key.PERSIST_ACROSS_REBOOT) { false }
var appendHttpProxy by configurationStore.boolean(Key.APPEND_HTTP_PROXY)
var connectionTestURL by configurationStore.string(Key.CONNECTION_TEST_URL) { CONNECTION_TEST_URL }
var connectionTestConcurrent by configurationStore.int("connectionTestConcurrent") { 5 }
var alwaysShowAddress by configurationStore.boolean(Key.ALWAYS_SHOW_ADDRESS)
var tunImplementation by configurationStore.stringToInt(Key.TUN_IMPLEMENTATION) { TunImplementation.MIXED }
var profileTrafficStatistics by configurationStore.boolean(Key.PROFILE_TRAFFIC_STATISTICS) { true }
var dashURL by configurationStore.string("dashURL") { "http://127.0.0.1:9090/ui" }
var enabledCazilla by configurationStore.boolean(Key.ENABLED_CAZILLA) { false }
// protocol
var muxType by configurationStore.stringToInt(Key.MUX_TYPE)
var muxProtocols by configurationStore.stringSet(Key.MUX_PROTOCOLS)
var muxConcurrency by configurationStore.stringToInt(Key.MUX_CONCURRENCY) { 8 }
var globalAllowInsecure by configurationStore.boolean(Key.GLOBAL_ALLOW_INSECURE) { false }
// old cache, DO NOT ADD
var dirty by profileCacheStore.boolean(Key.PROFILE_DIRTY)
var editingId by profileCacheStore.long(Key.PROFILE_ID)
var editingGroup by profileCacheStore.long(Key.PROFILE_GROUP)
var profileName by profileCacheStore.string(Key.PROFILE_NAME)
var serverAddress by profileCacheStore.string(Key.SERVER_ADDRESS)
var serverPort by profileCacheStore.stringToInt(Key.SERVER_PORT)
var serverPorts by profileCacheStore.string("serverPorts")
var serverUsername by profileCacheStore.string(Key.SERVER_USERNAME)
var serverPassword by profileCacheStore.string(Key.SERVER_PASSWORD)
var serverPassword1 by profileCacheStore.string(Key.SERVER_PASSWORD1)
var serverMethod by profileCacheStore.string(Key.SERVER_METHOD)
var sharedStorage by profileCacheStore.string("sharedStorage")
var serverProtocol by profileCacheStore.string(Key.SERVER_PROTOCOL)
var serverObfs by profileCacheStore.string(Key.SERVER_OBFS)
var serverNetwork by profileCacheStore.string(Key.SERVER_NETWORK)
var serverHost by profileCacheStore.string(Key.SERVER_HOST)
var serverPath by profileCacheStore.string(Key.SERVER_PATH)
var serverSNI by profileCacheStore.string(Key.SERVER_SNI)
var serverEncryption by profileCacheStore.string(Key.SERVER_ENCRYPTION)
var serverALPN by profileCacheStore.string(Key.SERVER_ALPN)
var serverCertificates by profileCacheStore.string(Key.SERVER_CERTIFICATES)
var serverHeaders by profileCacheStore.string(Key.SERVER_HEADERS)
var serverAllowInsecure by profileCacheStore.boolean(Key.SERVER_ALLOW_INSECURE)
// ECH
var ech by profileCacheStore.boolean(Key.ECH)
var echCfg by profileCacheStore.string(Key.ECH_CFG)
var serverAuthType by profileCacheStore.stringToInt(Key.SERVER_AUTH_TYPE)
var serverUploadSpeed by profileCacheStore.stringToInt(Key.SERVER_UPLOAD_SPEED)
var serverDownloadSpeed by profileCacheStore.stringToInt(Key.SERVER_DOWNLOAD_SPEED)
var serverStreamReceiveWindow by profileCacheStore.stringToIntIfExists(Key.SERVER_STREAM_RECEIVE_WINDOW)
var serverConnectionReceiveWindow by profileCacheStore.stringToIntIfExists(Key.SERVER_CONNECTION_RECEIVE_WINDOW)
var serverDisableMtuDiscovery by profileCacheStore.boolean(Key.SERVER_DISABLE_MTU_DISCOVERY)
var serverHopInterval by profileCacheStore.stringToInt(Key.SERVER_HOP_INTERVAL) { 10 }
var protocolVersion by profileCacheStore.stringToInt(Key.PROTOCOL_VERSION) { 2 } // default is SOCKS5
var serverProtocolInt by profileCacheStore.stringToInt(Key.SERVER_PROTOCOL)
var serverPrivateKey by profileCacheStore.string(Key.SERVER_PRIVATE_KEY)
var serverInsecureConcurrency by profileCacheStore.stringToInt(Key.SERVER_INSECURE_CONCURRENCY)
var serverUDPRelayMode by profileCacheStore.string(Key.SERVER_UDP_RELAY_MODE)
var serverCongestionController by profileCacheStore.string(Key.SERVER_CONGESTION_CONTROLLER)
var serverDisableSNI by profileCacheStore.boolean(Key.SERVER_DISABLE_SNI)
var serverReduceRTT by profileCacheStore.boolean(Key.SERVER_REDUCE_RTT)
var routeName by profileCacheStore.string(Key.ROUTE_NAME)
var routeDomain by profileCacheStore.string(Key.ROUTE_DOMAIN)
var routeIP by profileCacheStore.string(Key.ROUTE_IP)
var routePort by profileCacheStore.string(Key.ROUTE_PORT)
var routeSourcePort by profileCacheStore.string(Key.ROUTE_SOURCE_PORT)
var routeNetwork by profileCacheStore.string(Key.ROUTE_NETWORK)
var routeSource by profileCacheStore.string(Key.ROUTE_SOURCE)
var routeProtocol by profileCacheStore.string(Key.ROUTE_PROTOCOL)
var routeOutbound by profileCacheStore.stringToInt(Key.ROUTE_OUTBOUND)
var routeOutboundRule by profileCacheStore.long(Key.ROUTE_OUTBOUND + "Long")
var routePackages by profileCacheStore.string(Key.ROUTE_PACKAGES)
var routeSSID by profileCacheStore.string(Key.ROUTE_SSID)
var routeBSSID by profileCacheStore.string(Key.ROUTE_BSSID)
var frontProxy by profileCacheStore.long(Key.GROUP_FRONT_PROXY + "Long")
var landingProxy by profileCacheStore.long(Key.GROUP_LANDING_PROXY + "Long")
var frontProxyTmp by profileCacheStore.stringToInt(Key.GROUP_FRONT_PROXY)
var landingProxyTmp by profileCacheStore.stringToInt(Key.GROUP_LANDING_PROXY)
var serverConfig by profileCacheStore.string(Key.SERVER_CONFIG)
var serverCustom by profileCacheStore.string(Key.SERVER_CUSTOM)
var serverCustomOutbound by profileCacheStore.string(Key.SERVER_CUSTOM_OUTBOUND)
var groupName by profileCacheStore.string(Key.GROUP_NAME)
var groupType by profileCacheStore.stringToInt(Key.GROUP_TYPE)
var groupOrder by profileCacheStore.stringToInt(Key.GROUP_ORDER)
var groupIsSelector by profileCacheStore.boolean(Key.GROUP_IS_SELECTOR)
var subscriptionLink by profileCacheStore.string(Key.SUBSCRIPTION_LINK)
var subscriptionForceResolve by profileCacheStore.boolean(Key.SUBSCRIPTION_FORCE_RESOLVE)
var subscriptionDeduplication by profileCacheStore.boolean(Key.SUBSCRIPTION_DEDUPLICATION)
var subscriptionUpdateWhenConnectedOnly by profileCacheStore.boolean(Key.SUBSCRIPTION_UPDATE_WHEN_CONNECTED_ONLY)
var subscriptionUserAgent by profileCacheStore.string(Key.SUBSCRIPTION_USER_AGENT)
var subscriptionAutoUpdate by profileCacheStore.boolean(Key.SUBSCRIPTION_AUTO_UPDATE)
var subscriptionAutoUpdateDelay by profileCacheStore.stringToInt(Key.SUBSCRIPTION_AUTO_UPDATE_DELAY) { 360 }
var rulesFirstCreate by profileCacheStore.boolean("rulesFirstCreate")
override fun onPreferenceDataStoreChanged(store: PreferenceDataStore, key: String) {
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/database/DataStore.kt | 1263605345 |
package io.nekohasekai.sagernet.database
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import androidx.room.TypeConverters
import androidx.room.migration.Migration
import dev.matrix.roomigrant.GenerateRoomMigrations
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.fmt.KryoConverters
import io.nekohasekai.sagernet.fmt.gson.GsonConverters
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
val MIGRATIONS: Array<Migration> = arrayOf()
@Database(
entities = [ProxyGroup::class, ProxyEntity::class, RuleEntity::class],
version = 1
)
@TypeConverters(value = [KryoConverters::class, GsonConverters::class])
@GenerateRoomMigrations
abstract class SagerDatabase : RoomDatabase() {
companion object {
@OptIn(DelicateCoroutinesApi::class)
@Suppress("EXPERIMENTAL_API_USAGE")
val instance by lazy {
SagerNet.application.getDatabasePath(Key.DB_PROFILE).parentFile?.mkdirs()
Room.databaseBuilder(SagerNet.application, SagerDatabase::class.java, Key.DB_PROFILE)
.addMigrations(*MIGRATIONS)
.allowMainThreadQueries()
.enableMultiInstanceInvalidation()
.fallbackToDestructiveMigration()
.setQueryExecutor { GlobalScope.launch { it.run() } }
.build()
}
val groupDao get() = instance.groupDao()
val proxyDao get() = instance.proxyDao()
val rulesDao get() = instance.rulesDao()
}
abstract fun groupDao(): ProxyGroup.Dao
abstract fun proxyDao(): ProxyEntity.Dao
abstract fun rulesDao(): RuleEntity.Dao
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/SagerDatabase.kt | 2873626211 |
package io.nekohasekai.sagernet.database
import android.database.sqlite.SQLiteCantOpenDatabaseException
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.aidl.TrafficData
import io.nekohasekai.sagernet.fmt.AbstractBean
import io.nekohasekai.sagernet.ktx.Logs
import io.nekohasekai.sagernet.ktx.app
import io.nekohasekai.sagernet.ktx.applyDefaultValues
import java.io.IOException
import java.sql.SQLException
import java.util.*
object ProfileManager {
interface Listener {
suspend fun onAdd(profile: ProxyEntity)
suspend fun onUpdated(data: TrafficData)
suspend fun onUpdated(profile: ProxyEntity, noTraffic: Boolean)
suspend fun onRemoved(groupId: Long, profileId: Long)
}
interface RuleListener {
suspend fun onAdd(rule: RuleEntity)
suspend fun onUpdated(rule: RuleEntity)
suspend fun onRemoved(ruleId: Long)
suspend fun onCleared()
}
private val listeners = ArrayList<Listener>()
private val ruleListeners = ArrayList<RuleListener>()
suspend fun iterator(what: suspend Listener.() -> Unit) {
synchronized(listeners) {
listeners.toList()
}.forEach { listener ->
what(listener)
}
}
suspend fun ruleIterator(what: suspend RuleListener.() -> Unit) {
val ruleListeners = synchronized(ruleListeners) {
ruleListeners.toList()
}
for (listener in ruleListeners) {
what(listener)
}
}
fun addListener(listener: Listener) {
synchronized(listeners) {
listeners.add(listener)
}
}
fun removeListener(listener: Listener) {
synchronized(listeners) {
listeners.remove(listener)
}
}
fun addListener(listener: RuleListener) {
synchronized(ruleListeners) {
ruleListeners.add(listener)
}
}
fun removeListener(listener: RuleListener) {
synchronized(ruleListeners) {
ruleListeners.remove(listener)
}
}
suspend fun createProfile(groupId: Long, bean: AbstractBean): ProxyEntity {
bean.applyDefaultValues()
val profile = ProxyEntity(groupId = groupId).apply {
id = 0
putBean(bean)
userOrder = SagerDatabase.proxyDao.nextOrder(groupId) ?: 1
}
profile.id = SagerDatabase.proxyDao.addProxy(profile)
iterator { onAdd(profile) }
return profile
}
suspend fun updateProfile(profile: ProxyEntity) {
SagerDatabase.proxyDao.updateProxy(profile)
iterator { onUpdated(profile, false) }
}
suspend fun updateProfile(profiles: List<ProxyEntity>) {
SagerDatabase.proxyDao.updateProxy(profiles)
profiles.forEach {
iterator { onUpdated(it, false) }
}
}
suspend fun deleteProfile2(groupId: Long, profileId: Long) {
if (SagerDatabase.proxyDao.deleteById(profileId) == 0) return
if (DataStore.selectedProxy == profileId) {
DataStore.selectedProxy = 0L
}
}
suspend fun deleteProfile(groupId: Long, profileId: Long) {
if (SagerDatabase.proxyDao.deleteById(profileId) == 0) return
if (DataStore.selectedProxy == profileId) {
DataStore.selectedProxy = 0L
}
iterator { onRemoved(groupId, profileId) }
if (SagerDatabase.proxyDao.countByGroup(groupId) > 1) {
GroupManager.rearrange(groupId)
}
}
fun getProfile(profileId: Long): ProxyEntity? {
if (profileId == 0L) return null
return try {
SagerDatabase.proxyDao.getById(profileId)
} catch (ex: SQLiteCantOpenDatabaseException) {
throw IOException(ex)
} catch (ex: SQLException) {
Logs.w(ex)
null
}
}
fun getProfiles(profileIds: List<Long>): List<ProxyEntity> {
if (profileIds.isEmpty()) return listOf()
return try {
SagerDatabase.proxyDao.getEntities(profileIds)
} catch (ex: SQLiteCantOpenDatabaseException) {
throw IOException(ex)
} catch (ex: SQLException) {
Logs.w(ex)
listOf()
}
}
// postUpdate: post to listeners, don't change the DB
suspend fun postUpdate(profileId: Long, noTraffic: Boolean = false) {
postUpdate(getProfile(profileId) ?: return, noTraffic)
}
suspend fun postUpdate(profile: ProxyEntity, noTraffic: Boolean = false) {
iterator { onUpdated(profile, noTraffic) }
}
suspend fun postUpdate(data: TrafficData) {
iterator { onUpdated(data) }
}
suspend fun createRule(rule: RuleEntity, post: Boolean = true): RuleEntity {
rule.userOrder = SagerDatabase.rulesDao.nextOrder() ?: 1
rule.id = SagerDatabase.rulesDao.createRule(rule)
if (post) {
ruleIterator { onAdd(rule) }
}
return rule
}
suspend fun updateRule(rule: RuleEntity) {
SagerDatabase.rulesDao.updateRule(rule)
ruleIterator { onUpdated(rule) }
}
suspend fun deleteRule(ruleId: Long) {
SagerDatabase.rulesDao.deleteById(ruleId)
ruleIterator { onRemoved(ruleId) }
}
suspend fun deleteRules(rules: List<RuleEntity>) {
SagerDatabase.rulesDao.deleteRules(rules)
ruleIterator {
rules.forEach {
onRemoved(it.id)
}
}
}
suspend fun getRules(): List<RuleEntity> {
var rules = SagerDatabase.rulesDao.allRules()
if (rules.isEmpty() && !DataStore.rulesFirstCreate) {
DataStore.rulesFirstCreate = true
createRule(
RuleEntity(
name = app.getString(R.string.route_opt_block_quic),
port = "443",
network = "udp",
outbound = -2
)
)
createRule(
RuleEntity(
name = app.getString(R.string.route_opt_block_ads),
domains = "geosite:category-ads-all",
outbound = -2
)
)
createRule(
RuleEntity(
name = app.getString(R.string.route_opt_block_analysis),
domains = app.assets.open("analysis.txt").use {
it.bufferedReader()
.readLines()
.filter { it.isNotBlank() }
.joinToString("\n")
},
outbound = -2,
)
)
val fuckedCountry = mutableListOf("cn:中国")
if (Locale.getDefault().country != Locale.CHINA.country) {
// 非中文用户
fuckedCountry += "ir:Iran"
}
for (c in fuckedCountry) {
val country = c.substringBefore(":")
val displayCountry = c.substringAfter(":")
//
if (country == "cn") createRule(
RuleEntity(
name = app.getString(R.string.route_play_store, displayCountry),
domains = "domain:googleapis.cn",
), false
)
createRule(
RuleEntity(
name = app.getString(R.string.route_bypass_domain, displayCountry),
domains = "geosite:$country",
outbound = -1
), false
)
createRule(
RuleEntity(
name = app.getString(R.string.route_bypass_ip, displayCountry),
ip = "geoip:$country",
outbound = -1
), false
)
}
rules = SagerDatabase.rulesDao.allRules()
}
return rules
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/ProfileManager.kt | 2710921970 |
package io.nekohasekai.sagernet.database.preference
import android.os.Parcel
import android.os.Parcelable
import androidx.room.*
import java.io.ByteArrayOutputStream
import java.nio.ByteBuffer
@Entity
class KeyValuePair() : Parcelable {
companion object {
const val TYPE_UNINITIALIZED = 0
const val TYPE_BOOLEAN = 1
const val TYPE_FLOAT = 2
@Deprecated("Use TYPE_LONG.")
const val TYPE_INT = 3
const val TYPE_LONG = 4
const val TYPE_STRING = 5
const val TYPE_STRING_SET = 6
@JvmField
val CREATOR = object : Parcelable.Creator<KeyValuePair> {
override fun createFromParcel(parcel: Parcel): KeyValuePair {
return KeyValuePair(parcel)
}
override fun newArray(size: Int): Array<KeyValuePair?> {
return arrayOfNulls(size)
}
}
}
@androidx.room.Dao
interface Dao {
@Query("SELECT * FROM `KeyValuePair`")
fun all(): List<KeyValuePair>
@Query("SELECT * FROM `KeyValuePair` WHERE `key` = :key")
operator fun get(key: String): KeyValuePair?
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun put(value: KeyValuePair): Long
@Query("DELETE FROM `KeyValuePair` WHERE `key` = :key")
fun delete(key: String): Int
@Query("DELETE FROM `KeyValuePair`")
fun reset(): Int
@Insert
fun insert(list: List<KeyValuePair>)
}
@PrimaryKey
var key: String = ""
var valueType: Int = TYPE_UNINITIALIZED
var value: ByteArray = ByteArray(0)
val boolean: Boolean?
get() = if (valueType == TYPE_BOOLEAN) ByteBuffer.wrap(value).get() != 0.toByte() else null
val float: Float?
get() = if (valueType == TYPE_FLOAT) ByteBuffer.wrap(value).float else null
@Suppress("DEPRECATION")
@Deprecated("Use long.", ReplaceWith("long"))
val int: Int?
get() = if (valueType == TYPE_INT) ByteBuffer.wrap(value).int else null
val long: Long?
get() = when (valueType) {
@Suppress("DEPRECATION") TYPE_INT,
-> ByteBuffer.wrap(value).int.toLong()
TYPE_LONG -> ByteBuffer.wrap(value).long
else -> null
}
val string: String?
get() = if (valueType == TYPE_STRING) String(value) else null
val stringSet: Set<String>?
get() = if (valueType == TYPE_STRING_SET) {
val buffer = ByteBuffer.wrap(value)
val result = HashSet<String>()
while (buffer.hasRemaining()) {
val chArr = ByteArray(buffer.int)
buffer.get(chArr)
result.add(String(chArr))
}
result
} else null
@Ignore
constructor(key: String) : this() {
this.key = key
}
// putting null requires using DataStore
fun put(value: Boolean): KeyValuePair {
valueType = TYPE_BOOLEAN
this.value = ByteBuffer.allocate(1).put((if (value) 1 else 0).toByte()).array()
return this
}
fun put(value: Float): KeyValuePair {
valueType = TYPE_FLOAT
this.value = ByteBuffer.allocate(4).putFloat(value).array()
return this
}
@Suppress("DEPRECATION")
@Deprecated("Use long.")
fun put(value: Int): KeyValuePair {
valueType = TYPE_INT
this.value = ByteBuffer.allocate(4).putInt(value).array()
return this
}
fun put(value: Long): KeyValuePair {
valueType = TYPE_LONG
this.value = ByteBuffer.allocate(8).putLong(value).array()
return this
}
fun put(value: String): KeyValuePair {
valueType = TYPE_STRING
this.value = value.toByteArray()
return this
}
fun put(value: Set<String>): KeyValuePair {
valueType = TYPE_STRING_SET
val stream = ByteArrayOutputStream()
val intBuffer = ByteBuffer.allocate(4)
for (v in value) {
intBuffer.rewind()
stream.write(intBuffer.putInt(v.length).array())
stream.write(v.toByteArray())
}
this.value = stream.toByteArray()
return this
}
@Suppress("IMPLICIT_CAST_TO_ANY")
override fun toString(): String {
return when (valueType) {
TYPE_BOOLEAN -> boolean
TYPE_FLOAT -> float
TYPE_LONG -> long
TYPE_STRING -> string
TYPE_STRING_SET -> stringSet
else -> null
}?.toString() ?: "null"
}
constructor(parcel: Parcel) : this() {
key = parcel.readString()!!
valueType = parcel.readInt()
value = parcel.createByteArray()!!
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeString(key)
parcel.writeInt(valueType)
parcel.writeByteArray(value)
}
override fun describeContents(): Int {
return 0
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/preference/KeyValuePair.kt | 4015721037 |
package io.nekohasekai.sagernet.database.preference
import androidx.preference.PreferenceDataStore
interface OnPreferenceDataStoreChangeListener {
fun onPreferenceDataStoreChanged(store: PreferenceDataStore, key: String)
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/preference/OnPreferenceDataStoreChangeListener.kt | 476194703 |
package io.nekohasekai.sagernet.database.preference
import androidx.preference.PreferenceDataStore
@Suppress("MemberVisibilityCanBePrivate", "unused")
open class RoomPreferenceDataStore(private val kvPairDao: KeyValuePair.Dao) :
PreferenceDataStore() {
fun getBoolean(key: String) = kvPairDao[key]?.boolean
fun getFloat(key: String) = kvPairDao[key]?.float
fun getInt(key: String) = kvPairDao[key]?.long?.toInt()
fun getLong(key: String) = kvPairDao[key]?.long
fun getString(key: String) = kvPairDao[key]?.string
fun getStringSet(key: String) = kvPairDao[key]?.stringSet
fun reset() = kvPairDao.reset()
override fun getBoolean(key: String, defValue: Boolean) = getBoolean(key) ?: defValue
override fun getFloat(key: String, defValue: Float) = getFloat(key) ?: defValue
override fun getInt(key: String, defValue: Int) = getInt(key) ?: defValue
override fun getLong(key: String, defValue: Long) = getLong(key) ?: defValue
override fun getString(key: String, defValue: String?) = getString(key) ?: defValue
override fun getStringSet(key: String, defValue: MutableSet<String>?) =
getStringSet(key) ?: defValue
fun putBoolean(key: String, value: Boolean?) =
if (value == null) remove(key) else putBoolean(key, value)
fun putFloat(key: String, value: Float?) =
if (value == null) remove(key) else putFloat(key, value)
fun putInt(key: String, value: Int?) =
if (value == null) remove(key) else putLong(key, value.toLong())
fun putLong(key: String, value: Long?) = if (value == null) remove(key) else putLong(key, value)
override fun putBoolean(key: String, value: Boolean) {
kvPairDao.put(KeyValuePair(key).put(value))
fireChangeListener(key)
}
override fun putFloat(key: String, value: Float) {
kvPairDao.put(KeyValuePair(key).put(value))
fireChangeListener(key)
}
override fun putInt(key: String, value: Int) {
kvPairDao.put(KeyValuePair(key).put(value.toLong()))
fireChangeListener(key)
}
override fun putLong(key: String, value: Long) {
kvPairDao.put(KeyValuePair(key).put(value))
fireChangeListener(key)
}
override fun putString(key: String, value: String?) = if (value == null) remove(key) else {
kvPairDao.put(KeyValuePair(key).put(value))
fireChangeListener(key)
}
override fun putStringSet(key: String, values: MutableSet<String>?) =
if (values == null) remove(key) else {
kvPairDao.put(KeyValuePair(key).put(values))
fireChangeListener(key)
}
fun remove(key: String) {
kvPairDao.delete(key)
fireChangeListener(key)
}
private val listeners = HashSet<OnPreferenceDataStoreChangeListener>()
private fun fireChangeListener(key: String) {
val listeners = synchronized(listeners) {
listeners.toList()
}
listeners.forEach { it.onPreferenceDataStoreChanged(this, key) }
}
fun registerChangeListener(listener: OnPreferenceDataStoreChangeListener) {
synchronized(listeners) {
listeners.add(listener)
}
}
fun unregisterChangeListener(listener: OnPreferenceDataStoreChangeListener) {
synchronized(listeners) {
listeners.remove(listener)
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/preference/RoomPreferenceDataStore.kt | 3239456456 |
package io.nekohasekai.sagernet.database.preference
import android.graphics.Typeface
import android.text.InputFilter
import android.view.inputmethod.EditorInfo
import android.widget.EditText
import androidx.preference.EditTextPreference
object EditTextPreferenceModifiers {
object Monospace : EditTextPreference.OnBindEditTextListener {
override fun onBindEditText(editText: EditText) {
editText.typeface = Typeface.MONOSPACE
}
}
object Hosts : EditTextPreference.OnBindEditTextListener {
override fun onBindEditText(editText: EditText) {
editText.setHorizontallyScrolling(true)
editText.setSelection(editText.text.length)
}
}
object Port : EditTextPreference.OnBindEditTextListener {
private val portLengthFilter = arrayOf(InputFilter.LengthFilter(5))
override fun onBindEditText(editText: EditText) {
editText.inputType = EditorInfo.TYPE_CLASS_NUMBER
editText.filters = portLengthFilter
editText.setSingleLine()
editText.setSelection(editText.text.length)
}
}
object Number : EditTextPreference.OnBindEditTextListener {
override fun onBindEditText(editText: EditText) {
editText.inputType = EditorInfo.TYPE_CLASS_NUMBER
editText.setSingleLine()
editText.setSelection(editText.text.length)
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/preference/EditTextPreferenceModifiers.kt | 213093556 |
package io.nekohasekai.sagernet.database.preference
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import dev.matrix.roomigrant.GenerateRoomMigrations
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.SagerNet
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
@Database(entities = [KeyValuePair::class], version = 1)
@GenerateRoomMigrations
abstract class PublicDatabase : RoomDatabase() {
companion object {
val instance by lazy {
SagerNet.application.getDatabasePath(Key.DB_PROFILE).parentFile?.mkdirs()
Room.databaseBuilder(SagerNet.application, PublicDatabase::class.java, Key.DB_PUBLIC)
.allowMainThreadQueries()
.enableMultiInstanceInvalidation()
.fallbackToDestructiveMigration()
.setQueryExecutor { GlobalScope.launch { it.run() } }
.build()
}
val kvPairDao get() = instance.keyValuePairDao()
}
abstract fun keyValuePairDao(): KeyValuePair.Dao
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/preference/PublicDatabase.kt | 3029636893 |
package io.nekohasekai.sagernet.database
import androidx.room.TypeConverter
class ListConverter {
companion object {
@TypeConverter
@JvmStatic
fun fromList(list: List<String>): String {
return list.joinToString(",")
}
@TypeConverter
@JvmStatic
fun toList(string: String): List<String> {
return string.split(",")
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/ListConverter.kt | 3681933760 |
package io.nekohasekai.sagernet.database
import io.nekohasekai.sagernet.GroupType
import io.nekohasekai.sagernet.bg.SubscriptionUpdater
import io.nekohasekai.sagernet.ktx.applyDefaultValues
object GroupManager {
interface Listener {
suspend fun groupAdd(group: ProxyGroup)
suspend fun groupUpdated(group: ProxyGroup)
suspend fun groupRemoved(groupId: Long)
suspend fun groupUpdated(groupId: Long)
}
interface Interface {
suspend fun confirm(message: String): Boolean
suspend fun alert(message: String)
suspend fun onUpdateSuccess(
group: ProxyGroup,
changed: Int,
added: List<String>,
updated: Map<String, String>,
deleted: List<String>,
duplicate: List<String>,
byUser: Boolean
)
suspend fun onUpdateFailure(group: ProxyGroup, message: String)
}
private val listeners = ArrayList<Listener>()
var userInterface: Interface? = null
suspend fun iterator(what: suspend Listener.() -> Unit) {
synchronized(listeners) {
listeners.toList()
}.forEach { listener ->
what(listener)
}
}
fun addListener(listener: Listener) {
synchronized(listeners) {
listeners.add(listener)
}
}
fun removeListener(listener: Listener) {
synchronized(listeners) {
listeners.remove(listener)
}
}
suspend fun clearGroup(groupId: Long) {
DataStore.selectedProxy = 0L
SagerDatabase.proxyDao.deleteAll(groupId)
iterator { groupUpdated(groupId) }
}
fun rearrange(groupId: Long) {
val entities = SagerDatabase.proxyDao.getByGroup(groupId)
for (index in entities.indices) {
entities[index].userOrder = (index + 1).toLong()
}
SagerDatabase.proxyDao.updateProxy(entities)
}
suspend fun postUpdate(group: ProxyGroup) {
iterator { groupUpdated(group) }
}
suspend fun postUpdate(groupId: Long) {
postUpdate(SagerDatabase.groupDao.getById(groupId) ?: return)
}
suspend fun postReload(groupId: Long) {
iterator { groupUpdated(groupId) }
}
suspend fun createGroup(group: ProxyGroup): ProxyGroup {
group.userOrder = SagerDatabase.groupDao.nextOrder() ?: 1
group.id = SagerDatabase.groupDao.createGroup(group.applyDefaultValues())
iterator { groupAdd(group) }
if (group.type == GroupType.SUBSCRIPTION) {
SubscriptionUpdater.reconfigureUpdater()
}
return group
}
suspend fun updateGroup(group: ProxyGroup) {
SagerDatabase.groupDao.updateGroup(group)
iterator { groupUpdated(group) }
if (group.type == GroupType.SUBSCRIPTION) {
SubscriptionUpdater.reconfigureUpdater()
}
}
suspend fun deleteGroup(groupId: Long) {
SagerDatabase.groupDao.deleteById(groupId)
SagerDatabase.proxyDao.deleteByGroup(groupId)
iterator { groupRemoved(groupId) }
SubscriptionUpdater.reconfigureUpdater()
}
suspend fun deleteGroup(group: List<ProxyGroup>) {
SagerDatabase.groupDao.deleteGroup(group)
SagerDatabase.proxyDao.deleteByGroup(group.map { it.id }.toLongArray())
for (proxyGroup in group) iterator { groupRemoved(proxyGroup.id) }
SubscriptionUpdater.reconfigureUpdater()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/database/GroupManager.kt | 1994794426 |
package io.nekohasekai.sagernet.database
import android.os.Parcelable
import androidx.room.*
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.ktx.app
import kotlinx.parcelize.Parcelize
@Entity(tableName = "rules")
@Parcelize
@TypeConverters(ListConverter::class)
data class RuleEntity(
@PrimaryKey(autoGenerate = true) var id: Long = 0L,
var name: String = "",
var userOrder: Long = 0L,
var enabled: Boolean = false,
var domains: String = "",
var ip: String = "",
var port: String = "",
var sourcePort: String = "",
var network: String = "",
var source: String = "",
var protocol: String = "",
var outbound: Long = 0,
var packages: List<String> = listOf(),
) : Parcelable {
fun displayName(): String {
return name.takeIf { it.isNotBlank() } ?: "Rule $id"
}
fun mkSummary(): String {
var summary = ""
if (domains.isNotBlank()) summary += "$domains\n"
if (ip.isNotBlank()) summary += "$ip\n"
if (source.isNotBlank()) summary += "source: $source\n"
if (sourcePort.isNotBlank()) summary += "sourcePort: $sourcePort\n"
if (port.isNotBlank()) summary += "port: $port\n"
if (network.isNotBlank()) summary += "network: $network\n"
if (protocol.isNotBlank()) summary += "protocol: $protocol\n"
if (packages.isNotEmpty()) summary += app.getString(
R.string.apps_message, packages.size
) + "\n"
val lines = summary.trim().split("\n")
return if (lines.size > 3) {
lines.subList(0, 3).joinToString("\n", postfix = "\n...")
} else {
summary.trim()
}
}
fun displayOutbound(): String {
return when (outbound) {
0L -> app.getString(R.string.route_proxy)
-1L -> app.getString(R.string.route_bypass)
-2L -> app.getString(R.string.route_block)
else -> ProfileManager.getProfile(outbound)?.displayName()
?: app.getString(R.string.error_title)
}
}
@androidx.room.Dao
interface Dao {
@Query("SELECT * from rules WHERE (packages != '') AND enabled = 1")
fun checkVpnNeeded(): List<RuleEntity>
@Query("SELECT * FROM rules ORDER BY userOrder")
fun allRules(): List<RuleEntity>
@Query("SELECT * FROM rules WHERE enabled = :enabled ORDER BY userOrder")
fun enabledRules(enabled: Boolean = true): List<RuleEntity>
@Query("SELECT MAX(userOrder) + 1 FROM rules")
fun nextOrder(): Long?
@Query("SELECT * FROM rules WHERE id = :ruleId")
fun getById(ruleId: Long): RuleEntity?
@Query("DELETE FROM rules WHERE id = :ruleId")
fun deleteById(ruleId: Long): Int
@Delete
fun deleteRule(rule: RuleEntity)
@Delete
fun deleteRules(rules: List<RuleEntity>)
@Insert
fun createRule(rule: RuleEntity): Long
@Update
fun updateRule(rule: RuleEntity)
@Update
fun updateRules(rules: List<RuleEntity>)
@Query("DELETE FROM rules")
fun reset()
@Insert
fun insert(rules: List<RuleEntity>)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/database/RuleEntity.kt | 1144312431 |
package io.nekohasekai.sagernet.database
import android.content.Context
import android.content.Intent
import androidx.room.*
import com.esotericsoftware.kryo.io.ByteBufferInput
import com.esotericsoftware.kryo.io.ByteBufferOutput
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.fmt.*
import io.nekohasekai.sagernet.fmt.http.HttpBean
import io.nekohasekai.sagernet.fmt.http.toUri
import io.nekohasekai.sagernet.fmt.hysteria.HysteriaBean
import io.nekohasekai.sagernet.fmt.hysteria.buildHysteria1Config
import io.nekohasekai.sagernet.fmt.hysteria.canUseSingBox
import io.nekohasekai.sagernet.fmt.hysteria.toUri
import io.nekohasekai.sagernet.fmt.internal.ChainBean
import io.nekohasekai.sagernet.fmt.mieru.MieruBean
import io.nekohasekai.sagernet.fmt.mieru.buildMieruConfig
import io.nekohasekai.sagernet.fmt.naive.NaiveBean
import io.nekohasekai.sagernet.fmt.naive.buildNaiveConfig
import io.nekohasekai.sagernet.fmt.naive.toUri
import io.nekohasekai.sagernet.fmt.shadowsocks.ShadowsocksBean
import io.nekohasekai.sagernet.fmt.shadowsocks.toUri
import io.nekohasekai.sagernet.fmt.socks.SOCKSBean
import io.nekohasekai.sagernet.fmt.socks.toUri
import io.nekohasekai.sagernet.fmt.ssh.SSHBean
import io.nekohasekai.sagernet.fmt.trojan.TrojanBean
import io.nekohasekai.sagernet.fmt.trojan_go.TrojanGoBean
import io.nekohasekai.sagernet.fmt.trojan_go.buildTrojanGoConfig
import io.nekohasekai.sagernet.fmt.trojan_go.toUri
import io.nekohasekai.sagernet.fmt.tuic.TuicBean
import io.nekohasekai.sagernet.fmt.tuic.toUri
import io.nekohasekai.sagernet.fmt.v2ray.VMessBean
import io.nekohasekai.sagernet.fmt.v2ray.isTLS
import io.nekohasekai.sagernet.fmt.v2ray.toUriVMessVLESSTrojan
import io.nekohasekai.sagernet.fmt.wireguard.WireGuardBean
import io.nekohasekai.sagernet.ktx.app
import io.nekohasekai.sagernet.ktx.applyDefaultValues
import io.nekohasekai.sagernet.ui.profile.*
import moe.matsuri.nb4a.Protocols
import moe.matsuri.nb4a.proxy.config.ConfigBean
import moe.matsuri.nb4a.proxy.config.ConfigSettingActivity
import moe.matsuri.nb4a.proxy.neko.NekoBean
import moe.matsuri.nb4a.proxy.neko.NekoSettingActivity
import moe.matsuri.nb4a.proxy.neko.haveStandardLink
import moe.matsuri.nb4a.proxy.neko.shareLink
import moe.matsuri.nb4a.proxy.shadowtls.ShadowTLSBean
import moe.matsuri.nb4a.proxy.shadowtls.ShadowTLSSettingsActivity
@Entity(
tableName = "proxy_entities", indices = [Index("groupId", name = "groupId")]
)
data class ProxyEntity(
@PrimaryKey(autoGenerate = true) var id: Long = 0L,
var groupId: Long = 0L,
var type: Int = 0,
var userOrder: Long = 0L,
var tx: Long = 0L,
var rx: Long = 0L,
var status: Int = 0,
var ping: Int = 0,
var uuid: String = "",
var error: String? = null,
var socksBean: SOCKSBean? = null,
var httpBean: HttpBean? = null,
var ssBean: ShadowsocksBean? = null,
var vmessBean: VMessBean? = null,
var trojanBean: TrojanBean? = null,
var trojanGoBean: TrojanGoBean? = null,
var mieruBean: MieruBean? = null,
var naiveBean: NaiveBean? = null,
var hysteriaBean: HysteriaBean? = null,
var tuicBean: TuicBean? = null,
var sshBean: SSHBean? = null,
var wgBean: WireGuardBean? = null,
var shadowTLSBean: ShadowTLSBean? = null,
var chainBean: ChainBean? = null,
var nekoBean: NekoBean? = null,
var configBean: ConfigBean? = null,
) : Serializable() {
companion object {
const val TYPE_SOCKS = 0
const val TYPE_HTTP = 1
const val TYPE_SS = 2
const val TYPE_VMESS = 4
const val TYPE_TROJAN = 6
const val TYPE_TROJAN_GO = 7
const val TYPE_MIERU = 21
const val TYPE_NAIVE = 9
const val TYPE_HYSTERIA = 15
const val TYPE_TUIC = 20
const val TYPE_SSH = 17
const val TYPE_WG = 18
const val TYPE_SHADOWTLS = 19
const val TYPE_CONFIG = 998
const val TYPE_NEKO = 999
const val TYPE_CHAIN = 8
val chainName by lazy { app.getString(R.string.proxy_chain) }
private val placeHolderBean = SOCKSBean().applyDefaultValues()
@JvmField
val CREATOR = object : Serializable.CREATOR<ProxyEntity>() {
override fun newInstance(): ProxyEntity {
return ProxyEntity()
}
override fun newArray(size: Int): Array<ProxyEntity?> {
return arrayOfNulls(size)
}
}
}
@Ignore
@Transient
var dirty: Boolean = false
override fun initializeDefaultValues() {
}
override fun serializeToBuffer(output: ByteBufferOutput) {
output.writeInt(0)
output.writeLong(id)
output.writeLong(groupId)
output.writeInt(type)
output.writeLong(userOrder)
output.writeLong(tx)
output.writeLong(rx)
output.writeInt(status)
output.writeInt(ping)
output.writeString(uuid)
output.writeString(error)
val data = KryoConverters.serialize(requireBean())
output.writeVarInt(data.size, true)
output.writeBytes(data)
output.writeBoolean(dirty)
}
override fun deserializeFromBuffer(input: ByteBufferInput) {
val version = input.readInt()
id = input.readLong()
groupId = input.readLong()
type = input.readInt()
userOrder = input.readLong()
tx = input.readLong()
rx = input.readLong()
status = input.readInt()
ping = input.readInt()
uuid = input.readString()
error = input.readString()
putByteArray(input.readBytes(input.readVarInt(true)))
dirty = input.readBoolean()
}
fun putByteArray(byteArray: ByteArray) {
when (type) {
TYPE_SOCKS -> socksBean = KryoConverters.socksDeserialize(byteArray)
TYPE_HTTP -> httpBean = KryoConverters.httpDeserialize(byteArray)
TYPE_SS -> ssBean = KryoConverters.shadowsocksDeserialize(byteArray)
TYPE_VMESS -> vmessBean = KryoConverters.vmessDeserialize(byteArray)
TYPE_TROJAN -> trojanBean = KryoConverters.trojanDeserialize(byteArray)
TYPE_TROJAN_GO -> trojanGoBean = KryoConverters.trojanGoDeserialize(byteArray)
TYPE_MIERU -> mieruBean = KryoConverters.mieruDeserialize(byteArray)
TYPE_NAIVE -> naiveBean = KryoConverters.naiveDeserialize(byteArray)
TYPE_HYSTERIA -> hysteriaBean = KryoConverters.hysteriaDeserialize(byteArray)
TYPE_SSH -> sshBean = KryoConverters.sshDeserialize(byteArray)
TYPE_WG -> wgBean = KryoConverters.wireguardDeserialize(byteArray)
TYPE_TUIC -> tuicBean = KryoConverters.tuicDeserialize(byteArray)
TYPE_SHADOWTLS -> shadowTLSBean = KryoConverters.shadowTLSDeserialize(byteArray)
TYPE_CHAIN -> chainBean = KryoConverters.chainDeserialize(byteArray)
TYPE_NEKO -> nekoBean = KryoConverters.nekoDeserialize(byteArray)
TYPE_CONFIG -> configBean = KryoConverters.configDeserialize(byteArray)
}
}
fun displayType(): String = when (type) {
TYPE_SOCKS -> socksBean!!.protocolName()
TYPE_HTTP -> if (httpBean!!.isTLS()) "HTTPS" else "HTTP"
TYPE_SS -> "Shadowsocks"
TYPE_VMESS -> if (vmessBean!!.isVLESS) "VLESS" else "VMess"
TYPE_TROJAN -> "Trojan"
TYPE_TROJAN_GO -> "Trojan-Go"
TYPE_MIERU -> "Mieru"
TYPE_NAIVE -> "Naïve"
TYPE_HYSTERIA -> "Hysteria" + hysteriaBean!!.protocolVersion
TYPE_SSH -> "SSH"
TYPE_WG -> "WireGuard"
TYPE_TUIC -> "TUIC"
TYPE_SHADOWTLS -> "ShadowTLS"
TYPE_CHAIN -> chainName
TYPE_NEKO -> nekoBean!!.displayType()
TYPE_CONFIG -> configBean!!.displayType()
else -> "Undefined type $type"
}
fun displayName() = requireBean().displayName()
fun displayAddress() = requireBean().displayAddress()
fun requireBean(): AbstractBean {
return when (type) {
TYPE_SOCKS -> socksBean
TYPE_HTTP -> httpBean
TYPE_SS -> ssBean
TYPE_VMESS -> vmessBean
TYPE_TROJAN -> trojanBean
TYPE_TROJAN_GO -> trojanGoBean
TYPE_MIERU -> mieruBean
TYPE_NAIVE -> naiveBean
TYPE_HYSTERIA -> hysteriaBean
TYPE_SSH -> sshBean
TYPE_WG -> wgBean
TYPE_TUIC -> tuicBean
TYPE_SHADOWTLS -> shadowTLSBean
TYPE_CHAIN -> chainBean
TYPE_NEKO -> nekoBean
TYPE_CONFIG -> configBean
else -> error("Undefined type $type")
} ?: error("Null ${displayType()} profile")
}
fun haveLink(): Boolean {
return when (type) {
TYPE_CHAIN -> false
else -> true
}
}
fun haveStandardLink(): Boolean {
return when (requireBean()) {
is SSHBean -> false
is WireGuardBean -> false
is ShadowTLSBean -> false
is NekoBean -> nekoBean!!.haveStandardLink()
is ConfigBean -> false
else -> true
}
}
fun toStdLink(compact: Boolean = false): String = with(requireBean()) {
when (this) {
is SOCKSBean -> toUri()
is HttpBean -> toUri()
is ShadowsocksBean -> toUri()
is VMessBean -> toUriVMessVLESSTrojan(false)
is TrojanBean -> toUriVMessVLESSTrojan(true)
is TrojanGoBean -> toUri()
is NaiveBean -> toUri()
is HysteriaBean -> toUri()
is TuicBean -> toUri()
is NekoBean -> shareLink()
else -> toUniversalLink()
}
}
fun exportConfig(): Pair<String, String> {
var name = "${requireBean().displayName()}.json"
return with(requireBean()) {
StringBuilder().apply {
val config = buildConfig(this@ProxyEntity, forExport = true)
append(config.config)
if (!config.externalIndex.all { it.chain.isEmpty() }) {
name = "profiles.txt"
}
for ((chain) in config.externalIndex) {
chain.entries.forEachIndexed { index, (port, profile) ->
when (val bean = profile.requireBean()) {
is TrojanGoBean -> {
append("\n\n")
append(bean.buildTrojanGoConfig(port))
}
is MieruBean -> {
append("\n\n")
append(bean.buildMieruConfig(port))
}
is NaiveBean -> {
append("\n\n")
append(bean.buildNaiveConfig(port))
}
is HysteriaBean -> {
append("\n\n")
append(bean.buildHysteria1Config(port, null))
}
}
}
}
}.toString()
} to name
}
fun needExternal(): Boolean {
return when (type) {
TYPE_TROJAN_GO -> true
TYPE_MIERU -> true
TYPE_NAIVE -> true
TYPE_HYSTERIA -> !hysteriaBean!!.canUseSingBox()
TYPE_NEKO -> true
else -> false
}
}
fun needCoreMux(): Boolean {
return when (type) {
TYPE_VMESS -> if (vmessBean!!.isVLESS) {
Protocols.isProfileNeedMux(vmessBean!!) && Protocols.shouldEnableMux("vless")
} else {
Protocols.isProfileNeedMux(vmessBean!!) && Protocols.shouldEnableMux("vmess")
}
TYPE_TROJAN -> Protocols.isProfileNeedMux(trojanBean!!)
&& Protocols.shouldEnableMux("trojan")
TYPE_SS -> !ssBean!!.sUoT && Protocols.shouldEnableMux("shadowsocks")
else -> false
}
}
fun putBean(bean: AbstractBean): ProxyEntity {
socksBean = null
httpBean = null
ssBean = null
vmessBean = null
trojanBean = null
trojanGoBean = null
mieruBean = null
naiveBean = null
hysteriaBean = null
sshBean = null
wgBean = null
tuicBean = null
shadowTLSBean = null
chainBean = null
configBean = null
nekoBean = null
when (bean) {
is SOCKSBean -> {
type = TYPE_SOCKS
socksBean = bean
}
is HttpBean -> {
type = TYPE_HTTP
httpBean = bean
}
is ShadowsocksBean -> {
type = TYPE_SS
ssBean = bean
}
is VMessBean -> {
type = TYPE_VMESS
vmessBean = bean
}
is TrojanBean -> {
type = TYPE_TROJAN
trojanBean = bean
}
is TrojanGoBean -> {
type = TYPE_TROJAN_GO
trojanGoBean = bean
}
is MieruBean -> {
type = TYPE_MIERU
mieruBean = bean
}
is NaiveBean -> {
type = TYPE_NAIVE
naiveBean = bean
}
is HysteriaBean -> {
type = TYPE_HYSTERIA
hysteriaBean = bean
}
is SSHBean -> {
type = TYPE_SSH
sshBean = bean
}
is WireGuardBean -> {
type = TYPE_WG
wgBean = bean
}
is TuicBean -> {
type = TYPE_TUIC
tuicBean = bean
}
is ShadowTLSBean -> {
type = TYPE_SHADOWTLS
shadowTLSBean = bean
}
is ChainBean -> {
type = TYPE_CHAIN
chainBean = bean
}
is NekoBean -> {
type = TYPE_NEKO
nekoBean = bean
}
is ConfigBean -> {
type = TYPE_CONFIG
configBean = bean
}
else -> error("Undefined type $type")
}
return this
}
fun settingIntent(ctx: Context, isSubscription: Boolean): Intent {
return Intent(
ctx, when (type) {
TYPE_SOCKS -> SocksSettingsActivity::class.java
TYPE_HTTP -> HttpSettingsActivity::class.java
TYPE_SS -> ShadowsocksSettingsActivity::class.java
TYPE_VMESS -> VMessSettingsActivity::class.java
TYPE_TROJAN -> TrojanSettingsActivity::class.java
TYPE_TROJAN_GO -> TrojanGoSettingsActivity::class.java
TYPE_MIERU -> MieruSettingsActivity::class.java
TYPE_NAIVE -> NaiveSettingsActivity::class.java
TYPE_HYSTERIA -> HysteriaSettingsActivity::class.java
TYPE_SSH -> SSHSettingsActivity::class.java
TYPE_WG -> WireGuardSettingsActivity::class.java
TYPE_TUIC -> TuicSettingsActivity::class.java
TYPE_SHADOWTLS -> ShadowTLSSettingsActivity::class.java
TYPE_CHAIN -> ChainSettingsActivity::class.java
TYPE_NEKO -> NekoSettingActivity::class.java
TYPE_CONFIG -> ConfigSettingActivity::class.java
else -> throw IllegalArgumentException()
}
).apply {
putExtra(ProfileSettingsActivity.EXTRA_PROFILE_ID, id)
putExtra(ProfileSettingsActivity.EXTRA_IS_SUBSCRIPTION, isSubscription)
}
}
@androidx.room.Dao
interface Dao {
@Query("select * from proxy_entities")
fun getAll(): List<ProxyEntity>
@Query("SELECT id FROM proxy_entities WHERE groupId = :groupId ORDER BY userOrder")
fun getIdsByGroup(groupId: Long): List<Long>
@Query("SELECT * FROM proxy_entities WHERE groupId = :groupId ORDER BY userOrder")
fun getByGroup(groupId: Long): List<ProxyEntity>
@Query("SELECT * FROM proxy_entities WHERE id in (:proxyIds)")
fun getEntities(proxyIds: List<Long>): List<ProxyEntity>
@Query("SELECT COUNT(*) FROM proxy_entities WHERE groupId = :groupId")
fun countByGroup(groupId: Long): Long
@Query("SELECT MAX(userOrder) + 1 FROM proxy_entities WHERE groupId = :groupId")
fun nextOrder(groupId: Long): Long?
@Query("SELECT * FROM proxy_entities WHERE id = :proxyId")
fun getById(proxyId: Long): ProxyEntity?
@Query("DELETE FROM proxy_entities WHERE id IN (:proxyId)")
fun deleteById(proxyId: Long): Int
@Query("DELETE FROM proxy_entities WHERE groupId = :groupId")
fun deleteByGroup(groupId: Long)
@Query("DELETE FROM proxy_entities WHERE groupId in (:groupId)")
fun deleteByGroup(groupId: LongArray)
@Delete
fun deleteProxy(proxy: ProxyEntity): Int
@Delete
fun deleteProxy(proxies: List<ProxyEntity>): Int
@Update
fun updateProxy(proxy: ProxyEntity): Int
@Update
fun updateProxy(proxies: List<ProxyEntity>): Int
@Insert
fun addProxy(proxy: ProxyEntity): Long
@Insert
fun insert(proxies: List<ProxyEntity>)
@Query("DELETE FROM proxy_entities WHERE groupId = :groupId")
fun deleteAll(groupId: Long): Int
@Query("DELETE FROM proxy_entities")
fun reset()
}
override fun describeContents(): Int {
return 0
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/database/ProxyEntity.kt | 341254470 |
package io.nekohasekai.sagernet.aidl
import android.os.Parcelable
import kotlinx.parcelize.Parcelize
@Parcelize
data class SpeedDisplayData(
// Bytes per second
var txRateProxy: Long = 0L,
var rxRateProxy: Long = 0L,
var txRateDirect: Long = 0L,
var rxRateDirect: Long = 0L,
// Bytes for the current session
// Outbound "bypass" usage is not counted
var txTotal: Long = 0L,
var rxTotal: Long = 0L,
) : Parcelable
| nacs/app/src/main/java/io/nekohasekai/sagernet/aidl/SpeedDisplayData.kt | 2152998479 |
package io.nekohasekai.sagernet.aidl
import android.os.Parcelable
import kotlinx.parcelize.Parcelize
@Parcelize
data class TrafficData(
var id: Long = 0L,
var tx: Long = 0L,
var rx: Long = 0L,
) : Parcelable
| nacs/app/src/main/java/io/nekohasekai/sagernet/aidl/TrafficData.kt | 4222914073 |
package io.nekohasekai.sagernet.widget
import android.content.Context
import android.util.AttributeSet
import androidx.core.content.res.TypedArrayUtils
import androidx.preference.EditTextPreference
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.ktx.USER_AGENT
class UserAgentPreference
@JvmOverloads constructor(
context: Context, attrs: AttributeSet? = null, defStyle: Int = TypedArrayUtils.getAttr(
context, R.attr.editTextPreferenceStyle, android.R.attr.editTextPreferenceStyle
)
) : EditTextPreference(context, attrs, defStyle) {
public override fun notifyChanged() {
super.notifyChanged()
}
override fun getSummary(): CharSequence? {
if (text.isNullOrBlank()) {
return USER_AGENT
}
return super.getSummary()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/widget/UserAgentPreference.kt | 2393950828 |
package io.nekohasekai.sagernet.widget
import android.content.Context
import android.util.AttributeSet
import androidx.preference.Preference
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.ktx.app
import io.nekohasekai.sagernet.utils.PackageCache
class AppListPreference : Preference {
constructor(context: Context) : super(context)
constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
constructor(context: Context, attrs: AttributeSet?, defStyle: Int) : super(
context, attrs, defStyle
)
constructor(
context: Context, attrs: AttributeSet?, defStyleAttr: Int, defStyleRes: Int
) : super(context, attrs, defStyleAttr, defStyleRes)
override fun getSummary(): CharSequence {
val packages = DataStore.routePackages.split("\n").filter { it.isNotBlank() }.map {
PackageCache.installedPackages[it]?.applicationInfo?.loadLabel(app.packageManager)
?: PackageCache.installedPluginPackages[it]?.applicationInfo?.loadLabel(app.packageManager)
?: it
}
if (packages.isEmpty()) {
return context.getString(androidx.preference.R.string.not_set)
}
val count = packages.size
if (count <= 5) return packages.joinToString("\n")
return context.getString(R.string.apps_message, count)
}
fun postUpdate() {
notifyChanged()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/widget/AppListPreference.kt | 246754891 |
package io.nekohasekai.sagernet.widget
import android.content.Context
import android.util.AttributeSet
import android.view.View
import androidx.coordinatorlayout.widget.CoordinatorLayout
import com.google.android.material.progressindicator.CircularProgressIndicator
class FabProgressBehavior(context: Context, attrs: AttributeSet?) :
CoordinatorLayout.Behavior<CircularProgressIndicator>(context, attrs) {
override fun layoutDependsOn(
parent: CoordinatorLayout,
child: CircularProgressIndicator,
dependency: View,
): Boolean {
return dependency.id == (child.layoutParams as CoordinatorLayout.LayoutParams).anchorId
}
override fun onLayoutChild(
parent: CoordinatorLayout, child: CircularProgressIndicator,
layoutDirection: Int,
): Boolean {
val size = parent.getDependencies(child).single().measuredHeight + child.trackThickness
return if (child.indicatorSize != size) {
child.indicatorSize = size
true
} else false
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/widget/FabProgressBehavior.kt | 3786220503 |
package io.nekohasekai.sagernet.widget
import android.annotation.SuppressLint
import android.content.Context
import android.graphics.Rect
import android.util.AttributeSet
import android.view.MotionEvent
import androidx.appcompat.widget.AppCompatTextView
import androidx.core.view.isGone
class AutoCollapseTextView @JvmOverloads constructor(
context: Context, attrs: AttributeSet? = null,
defStyleAttr: Int = 0,
) :
AppCompatTextView(context, attrs, defStyleAttr) {
override fun onTextChanged(
text: CharSequence?,
start: Int,
lengthBefore: Int,
lengthAfter: Int,
) {
super.onTextChanged(text, start, lengthBefore, lengthAfter)
isGone = text.isNullOrEmpty()
}
// #1874
override fun onFocusChanged(focused: Boolean, direction: Int, previouslyFocusedRect: Rect?) =
try {
super.onFocusChanged(focused, direction, previouslyFocusedRect)
} catch (e: IndexOutOfBoundsException) {
}
@SuppressLint("ClickableViewAccessibility")
override fun onTouchEvent(event: MotionEvent?) = try {
super.onTouchEvent(event)
} catch (e: IndexOutOfBoundsException) {
false
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/widget/AutoCollapseTextView.kt | 920554862 |
package io.nekohasekai.sagernet.widget
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import androidx.core.graphics.Insets
import androidx.core.view.*
import io.nekohasekai.sagernet.R
object ListHolderListener : OnApplyWindowInsetsListener {
override fun onApplyWindowInsets(view: View, insets: WindowInsetsCompat): WindowInsetsCompat {
val statusBarInsets = insets.getInsets(WindowInsetsCompat.Type.statusBars())
view.setPadding(
statusBarInsets.left,
statusBarInsets.top,
statusBarInsets.right,
statusBarInsets.bottom
)
return WindowInsetsCompat.Builder(insets).apply {
setInsets(WindowInsetsCompat.Type.statusBars(), Insets.NONE)
/*setInsets(WindowInsetsCompat.Type.navigationBars(),
insets.getInsets(WindowInsetsCompat.Type.navigationBars()))*/
}.build()
}
fun setup(activity: AppCompatActivity) = activity.findViewById<View>(android.R.id.content).let {
ViewCompat.setOnApplyWindowInsetsListener(it, ListHolderListener)
WindowCompat.setDecorFitsSystemWindows(activity.window, false)
}
}
object MainListListener : OnApplyWindowInsetsListener {
override fun onApplyWindowInsets(view: View, insets: WindowInsetsCompat) = insets.apply {
view.updatePadding(
bottom = view.resources.getDimensionPixelOffset(R.dimen.main_list_padding_bottom) +
insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom
)
}
}
object ListListener : OnApplyWindowInsetsListener {
override fun onApplyWindowInsets(view: View, insets: WindowInsetsCompat) = insets.apply {
view.updatePadding(bottom = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/widget/WindowInsetsListeners.kt | 672272962 |
package io.nekohasekai.sagernet.widget
import android.content.Context
import android.util.AttributeSet
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProfileManager
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class OutboundPreference
@JvmOverloads constructor(
context: Context, attrs: AttributeSet? = null, defStyle: Int = R.attr.dropdownPreferenceStyle
) : SimpleMenuPreference(context, attrs, defStyle, 0) {
init {
setEntries(R.array.outbound_entry)
setEntryValues(R.array.outbound_value)
}
override fun getSummary(): CharSequence? {
if (value == "3") {
val routeOutbound = DataStore.profileCacheStore.getLong(key + "Long") ?: 0
if (routeOutbound > 0) {
ProfileManager.getProfile(routeOutbound)?.displayName()?.let {
return it
}
}
}
return super.getSummary()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/widget/OutboundPreference.kt | 1999717381 |
package io.nekohasekai.sagernet.widget
import android.content.Context
import android.util.AttributeSet
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.SagerDatabase
import moe.matsuri.nb4a.ui.SimpleMenuPreference
class GroupPreference
@JvmOverloads constructor(
context: Context, attrs: AttributeSet? = null, defStyle: Int = R.attr.dropdownPreferenceStyle
) : SimpleMenuPreference(context, attrs, defStyle, 0) {
init {
val groups = SagerDatabase.groupDao.allGroups()
entries = groups.map { it.displayName() }.toTypedArray()
entryValues = groups.map { "${it.id}" }.toTypedArray()
}
override fun getSummary(): CharSequence? {
if (!value.isNullOrBlank() && value != "0") {
return SagerDatabase.groupDao.getById(value.toLong())?.displayName()
?: super.getSummary()
}
return super.getSummary()
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/widget/GroupPreference.kt | 3085576894 |
package io.nekohasekai.sagernet.widget
import com.google.android.material.snackbar.Snackbar
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.ui.ThemedActivity
/**
* @param activity ThemedActivity.
* //@param view The view to find a parent from.
* @param undo Callback for undoing removals.
* @param commit Callback for committing removals.
* @tparam T Item type.
*/
class UndoSnackbarManager<in T>(
private val activity: ThemedActivity,
private val callback: Interface<T>,
) {
interface Interface<in T> {
fun undo(actions: List<Pair<Int, T>>)
fun commit(actions: List<Pair<Int, T>>)
}
private val recycleBin = ArrayList<Pair<Int, T>>()
private val removedCallback = object : Snackbar.Callback() {
override fun onDismissed(transientBottomBar: Snackbar?, event: Int) {
if (last === transientBottomBar && event != DISMISS_EVENT_ACTION) {
callback.commit(recycleBin)
recycleBin.clear()
last = null
}
}
}
private var last: Snackbar? = null
fun remove(items: Collection<Pair<Int, T>>) {
recycleBin.addAll(items)
val count = recycleBin.size
activity.snackbar(activity.resources.getQuantityString(R.plurals.removed, count, count))
.apply {
addCallback(removedCallback)
setAction(R.string.undo) {
callback.undo(recycleBin.reversed())
recycleBin.clear()
}
last = this
show()
}
}
fun remove(vararg items: Pair<Int, T>) = remove(items.toList())
fun flush() = last?.dismiss()
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/widget/UndoSnackbarManager.kt | 1777969925 |
package io.nekohasekai.sagernet.widget
import android.content.Context
import android.net.Uri
import android.util.AttributeSet
import androidx.core.content.res.TypedArrayUtils
import androidx.core.widget.addTextChangedListener
import androidx.preference.EditTextPreference
import com.google.android.material.textfield.TextInputLayout
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.ktx.app
import io.nekohasekai.sagernet.ktx.readableMessage
import okhttp3.HttpUrl.Companion.toHttpUrl
class LinkOrContentPreference
@JvmOverloads
constructor(
context: Context,
attrs: AttributeSet? = null,
defStyleAttr: Int = TypedArrayUtils.getAttr(
context, R.attr.editTextPreferenceStyle,
android.R.attr.editTextPreferenceStyle
),
defStyleRes: Int = 0
) : EditTextPreference(context, attrs, defStyleAttr, defStyleRes) {
init {
dialogLayoutResource = R.layout.layout_urltest_preference_dialog
setOnBindEditTextListener {
val linkLayout = it.rootView.findViewById<TextInputLayout>(R.id.input_layout)
fun validate() {
val link = it.text
if (link.isBlank()) {
linkLayout.isErrorEnabled = false
return
}
try {
if (Uri.parse(link.toString()).scheme == "content") {
linkLayout.isErrorEnabled = false
return
}
val url = link.toString().toHttpUrl()
if ("http".equals(url.scheme, true)) {
linkLayout.error = app.getString(R.string.cleartext_http_warning)
linkLayout.isErrorEnabled = true
} else {
linkLayout.isErrorEnabled = false
}
if (link.contains("\n")) {
linkLayout.error = "Unexpected new line"
}
} catch (e: Exception) {
linkLayout.error = e.readableMessage
linkLayout.isErrorEnabled = true
}
}
validate()
it.addTextChangedListener {
validate()
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/widget/LinkOrContentPreference.kt | 1322854028 |
package io.nekohasekai.sagernet.widget
import android.annotation.SuppressLint
import android.content.Context
import android.text.format.Formatter
import android.util.AttributeSet
import android.view.View
import android.widget.TextView
import androidx.appcompat.widget.TooltipCompat
import androidx.coordinatorlayout.widget.CoordinatorLayout
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.whenStarted
import com.google.android.material.bottomappbar.BottomAppBar
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.bg.BaseService
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.ktx.*
import io.nekohasekai.sagernet.ui.MainActivity
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
class StatsBar @JvmOverloads constructor(
context: Context, attrs: AttributeSet? = null,
defStyleAttr: Int = R.attr.bottomAppBarStyle,
) : BottomAppBar(context, attrs, defStyleAttr) {
private lateinit var statusText: TextView
private lateinit var txText: TextView
private lateinit var rxText: TextView
private lateinit var behavior: YourBehavior
var allowShow = true
override fun getBehavior(): YourBehavior {
if (!this::behavior.isInitialized) behavior = YourBehavior { allowShow }
return behavior
}
class YourBehavior(val getAllowShow: () -> Boolean) : Behavior() {
override fun onNestedScroll(
coordinatorLayout: CoordinatorLayout, child: BottomAppBar, target: View,
dxConsumed: Int, dyConsumed: Int, dxUnconsumed: Int, dyUnconsumed: Int,
type: Int, consumed: IntArray,
) {
super.onNestedScroll(
coordinatorLayout,
child,
target,
dxConsumed,
dyConsumed + dyUnconsumed,
dxUnconsumed,
0,
type,
consumed
)
}
override fun slideUp(child: BottomAppBar) {
if (!getAllowShow()) return
super.slideUp(child)
}
override fun slideDown(child: BottomAppBar) {
if (!getAllowShow()) return
super.slideDown(child)
}
}
override fun setOnClickListener(l: OnClickListener?) {
statusText = findViewById(R.id.status)
txText = findViewById(R.id.tx)
rxText = findViewById(R.id.rx)
super.setOnClickListener(l)
}
private fun setStatus(text: CharSequence) {
statusText.text = text
TooltipCompat.setTooltipText(this, text)
}
fun changeState(state: BaseService.State) {
val activity = context as MainActivity
fun postWhenStarted(what: () -> Unit) = activity.lifecycleScope.launch(Dispatchers.Main) {
delay(100L)
activity.whenStarted { what() }
}
if ((state == BaseService.State.Connected).also { hideOnScroll = it }) {
postWhenStarted {
if (allowShow) performShow()
setStatus(app.getText(R.string.vpn_connected))
}
} else {
postWhenStarted {
performHide()
}
updateSpeed(0, 0)
setStatus(
context.getText(
when (state) {
BaseService.State.Connecting -> R.string.connecting
BaseService.State.Stopping -> R.string.stopping
else -> R.string.not_connected
}
)
)
}
}
@SuppressLint("SetTextI18n")
fun updateSpeed(txRate: Long, rxRate: Long) {
txText.text = "▲ ${
context.getString(
R.string.speed, Formatter.formatFileSize(context, txRate)
)
}"
rxText.text = "▼ ${
context.getString(
R.string.speed, Formatter.formatFileSize(context, rxRate)
)
}"
}
fun testConnection() {
val activity = context as MainActivity
isEnabled = false
setStatus(app.getText(R.string.connection_test_testing))
runOnDefaultDispatcher {
try {
val elapsed = activity.urlTest()
onMainDispatcher {
isEnabled = true
setStatus(
app.getString(
if (DataStore.connectionTestURL.startsWith("https://")) {
R.string.connection_test_available
} else {
R.string.connection_test_available_http
}, elapsed
)
)
}
} catch (e: Exception) {
Logs.w(e.toString())
onMainDispatcher {
isEnabled = true
setStatus(app.getText(R.string.connection_test_testing))
activity.snackbar(
app.getString(
R.string.connection_test_error, e.readableMessage
)
).show()
}
}
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/widget/StatsBar.kt | 2085573219 |
package io.nekohasekai.sagernet.widget
import android.content.Context
import android.graphics.drawable.Drawable
import android.os.Build
import android.util.AttributeSet
import android.view.PointerIcon
import android.view.View
import androidx.annotation.DrawableRes
import androidx.appcompat.widget.TooltipCompat
import androidx.dynamicanimation.animation.DynamicAnimation
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.lifecycleScope
import androidx.vectordrawable.graphics.drawable.Animatable2Compat
import androidx.vectordrawable.graphics.drawable.AnimatedVectorDrawableCompat
import com.google.android.material.floatingactionbutton.FloatingActionButton
import com.google.android.material.progressindicator.BaseProgressIndicator
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.bg.BaseService
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import java.util.*
class ServiceButton @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyleAttr: Int = 0
) :
FloatingActionButton(context, attrs, defStyleAttr), DynamicAnimation.OnAnimationEndListener {
private val callback = object : Animatable2Compat.AnimationCallback() {
override fun onAnimationEnd(drawable: Drawable) {
super.onAnimationEnd(drawable)
var next = animationQueue.peek() ?: return
if (next.icon.current == drawable) {
animationQueue.pop()
next = animationQueue.peek() ?: return
}
next.start()
}
}
private inner class AnimatedState(
@DrawableRes resId: Int,
private val onStart: BaseProgressIndicator<*>.() -> Unit = { hideProgress() }
) {
val icon: AnimatedVectorDrawableCompat =
AnimatedVectorDrawableCompat.create(context, resId)!!.apply {
registerAnimationCallback([email protected])
}
fun start() {
setImageDrawable(icon)
icon.start()
progress.onStart()
}
fun stop() = icon.stop()
}
private val iconStopped by lazy { AnimatedState(R.drawable.ic_service_stopped) }
private val iconConnecting by lazy {
AnimatedState(R.drawable.ic_service_connecting) {
hideProgress()
delayedAnimation = (context as LifecycleOwner).lifecycleScope.launchWhenStarted {
delay(context.resources.getInteger(android.R.integer.config_mediumAnimTime) + 1000L)
isIndeterminate = true
show()
}
}
}
private val iconConnected by lazy {
AnimatedState(R.drawable.ic_service_connected) {
delayedAnimation?.cancel()
setProgressCompat(1, true)
}
}
private val iconStopping by lazy { AnimatedState(R.drawable.ic_service_stopping) }
private val animationQueue = ArrayDeque<AnimatedState>()
private var checked = false
private var delayedAnimation: Job? = null
private lateinit var progress: BaseProgressIndicator<*>
fun initProgress(progress: BaseProgressIndicator<*>) {
this.progress = progress
progress.progressDrawable?.addSpringAnimationEndListener(this)
}
override fun onAnimationEnd(
animation: DynamicAnimation<out DynamicAnimation<*>>?, canceled: Boolean, value: Float,
velocity: Float
) {
if (!canceled) progress.hide()
}
private fun hideProgress() {
delayedAnimation?.cancel()
progress.hide()
}
override fun onCreateDrawableState(extraSpace: Int): IntArray {
val drawableState = super.onCreateDrawableState(extraSpace + 1)
if (checked) View.mergeDrawableStates(
drawableState,
intArrayOf(android.R.attr.state_checked)
)
return drawableState
}
fun changeState(state: BaseService.State, previousState: BaseService.State, animate: Boolean) {
when (state) {
BaseService.State.Connecting -> changeState(iconConnecting, animate)
BaseService.State.Connected -> changeState(iconConnected, animate)
BaseService.State.Stopping -> {
changeState(iconStopping, animate && previousState == BaseService.State.Connected)
}
else -> changeState(iconStopped, animate)
}
checked = state == BaseService.State.Connected
refreshDrawableState()
val description = context.getText(if (state.canStop) R.string.stop else R.string.connect)
contentDescription = description
TooltipCompat.setTooltipText(this, description)
val enabled = state.canStop || state == BaseService.State.Stopped
isEnabled = enabled
if (Build.VERSION.SDK_INT >= 24) pointerIcon = PointerIcon.getSystemIcon(
context,
if (enabled) PointerIcon.TYPE_HAND else PointerIcon.TYPE_WAIT
)
}
private fun changeState(icon: AnimatedState, animate: Boolean) {
fun counters(a: AnimatedState, b: AnimatedState): Boolean =
a == iconStopped && b == iconConnecting ||
a == iconConnecting && b == iconStopped ||
a == iconConnected && b == iconStopping ||
a == iconStopping && b == iconConnected
if (animate) {
if (animationQueue.size < 2 || !counters(animationQueue.last, icon)) {
animationQueue.add(icon)
if (animationQueue.size == 1) icon.start()
} else animationQueue.removeLast()
} else {
animationQueue.peekFirst()?.stop()
animationQueue.clear()
icon.start() // force ensureAnimatorSet to be called so that stop() will work
icon.stop()
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/widget/ServiceButton.kt | 1435876502 |
package io.nekohasekai.sagernet.widget
import android.graphics.Bitmap
import android.graphics.Color
import android.os.Bundle
import android.util.DisplayMetrics
import android.view.Gravity
import android.view.LayoutInflater
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.LinearLayout
import android.widget.TextView
import androidx.core.os.bundleOf
import androidx.fragment.app.DialogFragment
import com.google.zxing.BarcodeFormat
import com.google.zxing.EncodeHintType
import com.google.zxing.MultiFormatWriter
import com.google.zxing.WriterException
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.ktx.Logs
import io.nekohasekai.sagernet.ktx.readableMessage
import io.nekohasekai.sagernet.ui.MainActivity
import java.nio.charset.StandardCharsets
import kotlin.math.roundToInt
class QRCodeDialog() : DialogFragment() {
companion object {
private const val KEY_URL = "io.nekohasekai.sagernet.QRCodeDialog.KEY_URL"
private const val KEY_NAME = "io.nekohasekai.sagernet.QRCodeDialog.KEY_NAME"
private val iso88591 = StandardCharsets.ISO_8859_1.newEncoder()
}
constructor(url: String, displayName: String) : this() {
arguments = bundleOf(
Pair(KEY_URL, url), Pair(KEY_NAME, displayName)
)
}
/**
* Based on:
* https://android.googlesource.com/platform/
packages/apps/Settings/+/0d706f0/src/com/android/settings/wifi/qrcode/QrCodeGenerator.java
* https://android.googlesource.com/platform/
packages/apps/Settings/+/8a9ccfd/src/com/android/settings/wifi/dpp/WifiDppQrCodeGeneratorFragment.java#153
*/
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
) = try {
// get display size
var pixelMin = 0
try {
val displayMetrics: DisplayMetrics = requireContext().resources.displayMetrics
val height: Int = displayMetrics.heightPixels
val width: Int = displayMetrics.widthPixels
pixelMin = if (height > width) width else height
pixelMin = (pixelMin * 0.8).roundToInt()
} catch (e: Exception) {
}
val size =
if (pixelMin > 0) pixelMin else resources.getDimensionPixelSize(R.dimen.qrcode_size)
// draw QR Code
val url = arguments?.getString(KEY_URL)!!
val displayName = arguments?.getString(KEY_NAME)!!
val hints = mutableMapOf<EncodeHintType, Any>()
if (!iso88591.canEncode(url)) hints[EncodeHintType.CHARACTER_SET] =
StandardCharsets.UTF_8.name()
val qrBits = MultiFormatWriter().encode(url, BarcodeFormat.QR_CODE, size, size, hints)
LinearLayout(context).apply {
// Layout
orientation = LinearLayout.VERTICAL
gravity = Gravity.CENTER
// QR Code Image View
addView(ImageView(context).apply {
layoutParams = ViewGroup.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT
)
setImageBitmap(Bitmap.createBitmap(size, size, Bitmap.Config.RGB_565).apply {
for (x in 0 until size) for (y in 0 until size) {
setPixel(x, y, if (qrBits.get(x, y)) Color.BLACK else Color.WHITE)
}
})
})
// Text View
addView(TextView(context).apply {
gravity = Gravity.CENTER
layoutParams = ViewGroup.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT
)
text = displayName
})
}
} catch (e: WriterException) {
Logs.w(e)
(activity as MainActivity).snackbar(e.readableMessage).show()
dismiss()
null
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/widget/QRCodeDialog.kt | 1845939183 |
package io.nekohasekai.sagernet.group
import io.nekohasekai.sagernet.IPv6Mode
import io.nekohasekai.sagernet.Key
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.GroupManager
import io.nekohasekai.sagernet.database.ProxyGroup
import io.nekohasekai.sagernet.database.SubscriptionBean
import io.nekohasekai.sagernet.fmt.AbstractBean
import io.nekohasekai.sagernet.fmt.http.HttpBean
import io.nekohasekai.sagernet.fmt.hysteria.HysteriaBean
import io.nekohasekai.sagernet.fmt.naive.NaiveBean
import io.nekohasekai.sagernet.fmt.trojan.TrojanBean
import io.nekohasekai.sagernet.fmt.trojan_go.TrojanGoBean
import io.nekohasekai.sagernet.fmt.v2ray.StandardV2RayBean
import io.nekohasekai.sagernet.fmt.v2ray.isTLS
import io.nekohasekai.sagernet.ktx.*
import kotlinx.coroutines.*
import java.net.Inet4Address
import java.net.InetAddress
import java.util.*
import java.util.concurrent.atomic.AtomicInteger
@Suppress("EXPERIMENTAL_API_USAGE")
abstract class GroupUpdater {
abstract suspend fun doUpdate(
proxyGroup: ProxyGroup,
subscription: SubscriptionBean,
userInterface: GroupManager.Interface?,
byUser: Boolean
)
data class Progress(
var max: Int
) {
var progress by AtomicInteger()
}
protected suspend fun forceResolve(
profiles: List<AbstractBean>, groupId: Long?
) {
val ipv6Mode = DataStore.ipv6Mode
val lookupPool = newFixedThreadPoolContext(5, "DNS Lookup")
val lookupJobs = mutableListOf<Job>()
val progress = Progress(profiles.size)
if (groupId != null) {
GroupUpdater.progress[groupId] = progress
GroupManager.postReload(groupId)
}
val ipv6First = ipv6Mode >= IPv6Mode.PREFER
for (profile in profiles) {
when (profile) {
// SNI rewrite unsupported
is NaiveBean -> continue
}
if (profile.serverAddress.isIpAddress()) continue
lookupJobs.add(GlobalScope.launch(lookupPool) {
try {
val results = if (
SagerNet.underlyingNetwork != null &&
DataStore.enableFakeDns &&
DataStore.serviceState.started &&
DataStore.serviceMode == Key.MODE_VPN
) {
// FakeDNS
SagerNet.underlyingNetwork!!
.getAllByName(profile.serverAddress)
.filterNotNull()
} else {
// System DNS is enough (when VPN connected, it uses v2ray-core)
InetAddress.getAllByName(profile.serverAddress).filterNotNull()
}
if (results.isEmpty()) error("empty response")
rewriteAddress(profile, results, ipv6First)
} catch (e: Exception) {
Logs.d("Lookup ${profile.serverAddress} failed: ${e.readableMessage}", e)
}
if (groupId != null) {
progress.progress++
GroupManager.postReload(groupId)
}
})
}
lookupJobs.joinAll()
lookupPool.close()
}
protected fun rewriteAddress(
bean: AbstractBean, addresses: List<InetAddress>, ipv6First: Boolean
) {
val address = addresses.sortedBy { (it is Inet4Address) xor ipv6First }[0].hostAddress
with(bean) {
when (this) {
is HttpBean -> {
if (isTLS() && sni.isBlank()) sni = bean.serverAddress
}
is StandardV2RayBean -> {
when (security) {
"tls" -> if (sni.isBlank()) sni = bean.serverAddress
}
}
is TrojanBean -> {
if (sni.isBlank()) sni = bean.serverAddress
}
is TrojanGoBean -> {
if (sni.isBlank()) sni = bean.serverAddress
}
is HysteriaBean -> {
if (sni.isBlank()) sni = bean.serverAddress
}
}
bean.serverAddress = address
}
}
companion object {
val updating = Collections.synchronizedSet<Long>(mutableSetOf())
val progress = Collections.synchronizedMap<Long, Progress>(mutableMapOf())
fun startUpdate(proxyGroup: ProxyGroup, byUser: Boolean) {
runOnDefaultDispatcher {
executeUpdate(proxyGroup, byUser)
}
}
suspend fun executeUpdate(proxyGroup: ProxyGroup, byUser: Boolean): Boolean {
return coroutineScope {
if (!updating.add(proxyGroup.id)) cancel()
GroupManager.postReload(proxyGroup.id)
val subscription = proxyGroup.subscription!!
val connected = DataStore.serviceState.connected
val userInterface = GroupManager.userInterface
if (byUser && (subscription.link?.startsWith("http://") == true || subscription.updateWhenConnectedOnly) && !connected) {
if (userInterface == null || !userInterface.confirm(app.getString(R.string.update_subscription_warning))) {
finishUpdate(proxyGroup)
cancel()
return@coroutineScope true
}
}
try {
RawUpdater.doUpdate(proxyGroup, subscription, userInterface, byUser)
true
} catch (e: Throwable) {
Logs.w(e)
userInterface?.onUpdateFailure(proxyGroup, e.readableMessage)
finishUpdate(proxyGroup)
false
}
}
}
suspend fun finishUpdate(proxyGroup: ProxyGroup) {
updating.remove(proxyGroup.id)
progress.remove(proxyGroup.id)
GroupManager.postUpdate(proxyGroup)
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/group/GroupUpdater.kt | 3241639010 |
package io.nekohasekai.sagernet.group
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.GroupManager
import io.nekohasekai.sagernet.database.ProxyGroup
import io.nekohasekai.sagernet.ktx.onMainDispatcher
import io.nekohasekai.sagernet.ktx.runOnMainDispatcher
import io.nekohasekai.sagernet.ui.ThemedActivity
import kotlinx.coroutines.delay
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine
class GroupInterfaceAdapter(val context: ThemedActivity) : GroupManager.Interface {
override suspend fun confirm(message: String): Boolean {
return suspendCoroutine {
runOnMainDispatcher {
MaterialAlertDialogBuilder(context).setTitle(R.string.confirm)
.setMessage(message)
.setPositiveButton(R.string.yes) { _, _ -> it.resume(true) }
.setNegativeButton(R.string.no) { _, _ -> it.resume(false) }
.setOnCancelListener { _ -> it.resume(false) }
.show()
}
}
}
override suspend fun onUpdateSuccess(
group: ProxyGroup,
changed: Int,
added: List<String>,
updated: Map<String, String>,
deleted: List<String>,
duplicate: List<String>,
byUser: Boolean
) {
if (changed == 0 && duplicate.isEmpty()) {
if (byUser) context.snackbar(
context.getString(
R.string.group_no_difference, group.displayName()
)
).show()
} else {
context.snackbar(context.getString(R.string.group_updated, group.name, changed)).show()
var status = ""
if (added.isNotEmpty()) {
status += context.getString(
R.string.group_added, added.joinToString("\n", postfix = "\n\n")
)
}
if (updated.isNotEmpty()) {
status += context.getString(R.string.group_changed,
updated.map { it }.joinToString("\n", postfix = "\n\n") {
if (it.key == it.value) it.key else "${it.key} => ${it.value}"
})
}
if (deleted.isNotEmpty()) {
status += context.getString(
R.string.group_deleted, deleted.joinToString("\n", postfix = "\n\n")
)
}
if (duplicate.isNotEmpty()) {
status += context.getString(
R.string.group_duplicate, duplicate.joinToString("\n", postfix = "\n\n")
)
}
onMainDispatcher {
delay(1000L)
MaterialAlertDialogBuilder(context).setTitle(
context.getString(
R.string.group_diff, group.displayName()
)
).setMessage(status.trim()).setPositiveButton(android.R.string.ok, null).show()
}
}
}
override suspend fun onUpdateFailure(group: ProxyGroup, message: String) {
onMainDispatcher {
context.snackbar(message).show()
}
}
override suspend fun alert(message: String) {
return suspendCoroutine {
runOnMainDispatcher {
MaterialAlertDialogBuilder(context).setTitle(R.string.ooc_warning)
.setMessage(message)
.setPositiveButton(android.R.string.ok) { _, _ -> it.resume(Unit) }
.setOnCancelListener { _ -> it.resume(Unit) }
.show()
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/group/GroupInterfaceAdapter.kt | 889792845 |
package io.nekohasekai.sagernet.group
import android.annotation.SuppressLint
import android.net.Uri
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.database.*
import io.nekohasekai.sagernet.fmt.AbstractBean
import io.nekohasekai.sagernet.fmt.http.HttpBean
import io.nekohasekai.sagernet.fmt.hysteria.HysteriaBean
import io.nekohasekai.sagernet.fmt.hysteria.parseHysteria1Json
import io.nekohasekai.sagernet.fmt.shadowsocks.ShadowsocksBean
import io.nekohasekai.sagernet.fmt.shadowsocks.parseShadowsocks
import io.nekohasekai.sagernet.fmt.socks.SOCKSBean
import io.nekohasekai.sagernet.fmt.trojan.TrojanBean
import io.nekohasekai.sagernet.fmt.trojan_go.parseTrojanGo
import io.nekohasekai.sagernet.fmt.tuic.TuicBean
import io.nekohasekai.sagernet.fmt.v2ray.StandardV2RayBean
import io.nekohasekai.sagernet.fmt.v2ray.VMessBean
import io.nekohasekai.sagernet.fmt.v2ray.isTLS
import io.nekohasekai.sagernet.fmt.v2ray.setTLS
import io.nekohasekai.sagernet.fmt.wireguard.WireGuardBean
import io.nekohasekai.sagernet.ktx.*
import libcore.Libcore
import moe.matsuri.nb4a.Protocols
import moe.matsuri.nb4a.proxy.config.ConfigBean
import org.ini4j.Ini
import org.json.JSONArray
import org.json.JSONObject
import org.json.JSONTokener
import org.yaml.snakeyaml.TypeDescription
import org.yaml.snakeyaml.Yaml
import org.yaml.snakeyaml.error.YAMLException
import java.io.StringReader
@Suppress("EXPERIMENTAL_API_USAGE")
object RawUpdater : GroupUpdater() {
@SuppressLint("Recycle")
override suspend fun doUpdate(
proxyGroup: ProxyGroup,
subscription: SubscriptionBean,
userInterface: GroupManager.Interface?,
byUser: Boolean
) {
val link = subscription.link
var proxies: List<AbstractBean>
if (link.startsWith("content://")) {
val contentText = app.contentResolver.openInputStream(Uri.parse(link))
?.bufferedReader()
?.readText()
proxies = contentText?.let { parseRaw(contentText) }
?: error(app.getString(R.string.no_proxies_found_in_subscription))
} else {
val response = Libcore.newHttpClient().apply {
trySocks5(DataStore.mixedPort)
when (DataStore.appTLSVersion) {
"1.3" -> restrictedTLS()
}
setInsecure(DataStore.allowInsecureOnRequest)
useCazilla(DataStore.enabledCazilla)
}.newRequest().apply {
setURL(subscription.link)
setUserAgent(subscription.customUserAgent.takeIf { it.isNotBlank() } ?: USER_AGENT)
}.execute()
proxies = parseRaw(response.contentString)
?: error(app.getString(R.string.no_proxies_found))
subscription.subscriptionUserinfo = response.getHeader("Subscription-Userinfo")
}
val proxiesMap = LinkedHashMap<String, AbstractBean>()
for (proxy in proxies) {
var index = 0
var name = proxy.displayName()
while (proxiesMap.containsKey(name)) {
println("Exists name: $name")
index++
name = name.replace(" (${index - 1})", "")
name = "$name ($index)"
proxy.name = name
}
proxiesMap[proxy.displayName()] = proxy
}
proxies = proxiesMap.values.toList()
if (subscription.forceResolve) forceResolve(proxies, proxyGroup.id)
val exists = SagerDatabase.proxyDao.getByGroup(proxyGroup.id)
val duplicate = ArrayList<String>()
if (subscription.deduplication) {
Logs.d("Before deduplication: ${proxies.size}")
val uniqueProxies = LinkedHashSet<Protocols.Deduplication>()
val uniqueNames = HashMap<Protocols.Deduplication, String>()
for (_proxy in proxies) {
val proxy = Protocols.Deduplication(_proxy, _proxy.javaClass.toString())
if (!uniqueProxies.add(proxy)) {
val index = uniqueProxies.indexOf(proxy)
if (uniqueNames.containsKey(proxy)) {
val name = uniqueNames[proxy]!!.replace(" ($index)", "")
if (name.isNotBlank()) {
duplicate.add("$name ($index)")
uniqueNames[proxy] = ""
}
}
duplicate.add(_proxy.displayName() + " ($index)")
} else {
uniqueNames[proxy] = _proxy.displayName()
}
}
uniqueProxies.retainAll(uniqueNames.keys)
proxies = uniqueProxies.toList().map { it.bean }
}
Logs.d("New profiles: ${proxies.size}")
val nameMap = proxies.associateBy { bean ->
bean.displayName()
}
Logs.d("Unique profiles: ${nameMap.size}")
val toDelete = ArrayList<ProxyEntity>()
val toReplace = exists.mapNotNull { entity ->
val name = entity.displayName()
if (nameMap.contains(name)) name to entity else let {
toDelete.add(entity)
null
}
}.toMap()
Logs.d("toDelete profiles: ${toDelete.size}")
Logs.d("toReplace profiles: ${toReplace.size}")
val toUpdate = ArrayList<ProxyEntity>()
val added = mutableListOf<String>()
val updated = mutableMapOf<String, String>()
val deleted = toDelete.map { it.displayName() }
var userOrder = 1L
var changed = toDelete.size
for ((name, bean) in nameMap.entries) {
if (toReplace.contains(name)) {
val entity = toReplace[name]!!
val existsBean = entity.requireBean()
existsBean.applyFeatureSettings(bean)
when {
existsBean != bean -> {
changed++
entity.putBean(bean)
toUpdate.add(entity)
updated[entity.displayName()] = name
Logs.d("Updated profile: $name")
}
entity.userOrder != userOrder -> {
entity.putBean(bean)
toUpdate.add(entity)
entity.userOrder = userOrder
Logs.d("Reordered profile: $name")
}
else -> {
Logs.d("Ignored profile: $name")
}
}
} else {
changed++
SagerDatabase.proxyDao.addProxy(ProxyEntity(
groupId = proxyGroup.id, userOrder = userOrder
).apply {
putBean(bean)
})
added.add(name)
Logs.d("Inserted profile: $name")
}
userOrder++
}
SagerDatabase.proxyDao.updateProxy(toUpdate).also {
Logs.d("Updated profiles: $it")
}
SagerDatabase.proxyDao.deleteProxy(toDelete).also {
Logs.d("Deleted profiles: $it")
}
val existCount = SagerDatabase.proxyDao.countByGroup(proxyGroup.id).toInt()
if (existCount != proxies.size) {
Logs.e("Exist profiles: $existCount, new profiles: ${proxies.size}")
}
subscription.lastUpdated = (System.currentTimeMillis() / 1000).toInt()
SagerDatabase.groupDao.updateGroup(proxyGroup)
finishUpdate(proxyGroup)
userInterface?.onUpdateSuccess(
proxyGroup, changed, added, updated, deleted, duplicate, byUser
)
}
@Suppress("UNCHECKED_CAST")
suspend fun parseRaw(text: String, fileName: String = ""): List<AbstractBean>? {
val proxies = mutableListOf<AbstractBean>()
if (text.contains("proxies:")) {
// clash & meta
try {
val yaml = Yaml().apply {
addTypeDescription(TypeDescription(String::class.java, "str"))
}.loadAs(text, Map::class.java)
val globalClientFingerprint = yaml["global-client-fingerprint"]?.toString() ?: ""
for (proxy in (yaml["proxies"] as? (List<Map<String, Any?>>) ?: error(
app.getString(R.string.no_proxies_found_in_file)
))) {
// Note: YAML numbers parsed as "Long"
when (proxy["type"] as String) {
"socks5" -> {
proxies.add(SOCKSBean().apply {
serverAddress = proxy["server"] as String
serverPort = proxy["port"].toString().toInt()
username = proxy["username"]?.toString()
password = proxy["password"]?.toString()
name = proxy["name"]?.toString()
})
}
"http" -> {
proxies.add(HttpBean().apply {
serverAddress = proxy["server"] as String
serverPort = proxy["port"].toString().toInt()
username = proxy["username"]?.toString()
password = proxy["password"]?.toString()
setTLS(proxy["tls"]?.toString() == "true")
sni = proxy["sni"]?.toString()
name = proxy["name"]?.toString()
})
}
"ss" -> {
val ssPlugin = mutableListOf<String>()
if (proxy.contains("plugin")) {
val opts = proxy["plugin-opts"] as Map<String, Any?>
when (proxy["plugin"]) {
"obfs" -> {
ssPlugin.apply {
add("obfs-local")
add("obfs=" + (opts["mode"]?.toString() ?: ""))
add("obfs-host=" + (opts["host"]?.toString() ?: ""))
}
}
"v2ray-plugin" -> {
ssPlugin.apply {
add("v2ray-plugin")
add("mode=" + (opts["mode"]?.toString() ?: ""))
if (opts["mode"]?.toString() == "true") add("tls")
add("host=" + (opts["host"]?.toString() ?: ""))
add("path=" + (opts["path"]?.toString() ?: ""))
if (opts["mux"]?.toString() == "true") add("mux=8")
}
}
}
}
proxies.add(ShadowsocksBean().apply {
serverAddress = proxy["server"] as String
serverPort = proxy["port"].toString().toInt()
password = proxy["password"]?.toString()
method = clashCipher(proxy["cipher"] as String)
plugin = ssPlugin.joinToString(";")
name = proxy["name"]?.toString()
sUoT = proxy["udp-over-tcp"]?.toString() == "true"
})
}
"vmess", "vless" -> {
val isVLESS = proxy["type"].toString() == "vless"
val bean = VMessBean().apply {
if (isVLESS) {
alterId = -1 // make it VLESS
packetEncoding = 2 // clash meta default XUDP
}
}
for (opt in proxy) {
if (opt.value == null) continue
when (opt.key.replace("_", "-")) {
"name" -> bean.name = opt.value.toString()
"server" -> bean.serverAddress = opt.value as String
"port" -> bean.serverPort = opt.value.toString().toInt()
"uuid" -> bean.uuid = opt.value as String
"alterId" -> if (!isVLESS) bean.alterId =
opt.value.toString().toInt()
"cipher" -> if (!isVLESS) bean.encryption = opt.value as String
"flow" -> if (isVLESS) bean.encryption = opt.value as String
"packet-addr" -> if (opt.value.toString() == "true") {
bean.packetEncoding = 1
}
"xudp" -> if (opt.value.toString() == "true") {
bean.packetEncoding = 2
}
"network" -> {
bean.type = opt.value as String
// Clash "network" fix
when (bean.type) {
"h2" -> bean.type = "http"
}
}
"client-fingerprint" -> bean.utlsFingerprint =
opt.value as String
"tls" -> bean.security =
if (opt.value.toString() == "true") "tls" else ""
"servername" -> bean.sni = opt.value.toString()
"skip-cert-verify" -> bean.allowInsecure =
opt.value.toString() == "true"
"alpn" -> {
val alpn = (opt.value as? (List<String>))
bean.alpn = alpn?.joinToString("\n")
}
"ws-path" -> bean.path = opt.value.toString()
"ws-headers" -> for (wsHeader in (opt.value as Map<String, Any>)) {
when (wsHeader.key.lowercase()) {
"host" -> bean.host = wsHeader.value.toString()
}
}
"ws-opts", "ws-opt" -> for (wsOpt in (opt.value as Map<String, Any>)) {
when (wsOpt.key.lowercase()) {
"headers" -> for (wsHeader in (wsOpt.value as Map<String, Any>)) {
when (wsHeader.key.lowercase()) {
"host" -> bean.host = wsHeader.value.toString()
}
}
"path" -> {
bean.path = wsOpt.value.toString()
}
"max-early-data" -> {
bean.wsMaxEarlyData = wsOpt.value.toString().toInt()
}
"early-data-header-name" -> {
bean.earlyDataHeaderName = wsOpt.value.toString()
}
}
}
// The format of the VMessBean is wrong, so the `host` `path` has some strange transformations here.
"h2-opts", "h2-opt" -> for (h2Opt in (opt.value as Map<String, Any>)) {
when (h2Opt.key.lowercase()) {
"host" -> bean.host =
(h2Opt.value as List<String>).first()
"path" -> bean.path = h2Opt.value.toString()
}
}
"http-opts", "http-opt" -> for (httpOpt in (opt.value as Map<String, Any>)) {
when (httpOpt.key.lowercase()) {
"path" -> bean.path =
(httpOpt.value as List<String>).first()
"headers" -> for (hdr in (httpOpt.value as Map<String, Any>)) {
when (hdr.key.lowercase()) {
"host" -> bean.host =
(hdr.value as List<String>).first()
}
}
}
}
"grpc-opts", "grpc-opt" -> for (grpcOpt in (opt.value as Map<String, Any>)) {
when (grpcOpt.key.lowercase()) {
"grpc-service-name" -> bean.path =
grpcOpt.value.toString()
}
}
"reality-opts" -> for (realityOpt in (opt.value as Map<String, Any>)) {
when (realityOpt.key.lowercase()) {
"public-key" -> bean.realityPubKey =
realityOpt.value.toString()
"short-id" -> bean.realityShortId =
realityOpt.value.toString()
}
}
}
}
proxies.add(bean)
}
"trojan" -> {
val bean = TrojanBean()
bean.security = "tls"
for (opt in proxy) {
if (opt.value == null) continue
when (opt.key.replace("_", "-")) {
"name" -> bean.name = opt.value.toString()
"server" -> bean.serverAddress = opt.value as String
"port" -> bean.serverPort = opt.value.toString().toInt()
"password" -> bean.password = opt.value.toString()
"client-fingerprint" -> bean.utlsFingerprint =
opt.value as String
"sni" -> bean.sni = opt.value.toString()
"skip-cert-verify" -> bean.allowInsecure =
opt.value.toString() == "true"
"alpn" -> {
val alpn = (opt.value as? (List<String>))
bean.alpn = alpn?.joinToString("\n")
}
"network" -> when (opt.value) {
"ws", "grpc" -> bean.type = opt.value.toString()
}
"ws-opts", "ws-opt" -> for (wsOpt in (opt.value as Map<String, Any>)) {
when (wsOpt.key.lowercase()) {
"headers" -> for (wsHeader in (wsOpt.value as Map<String, Any>)) {
when (wsHeader.key.lowercase()) {
"host" -> bean.host = wsHeader.value.toString()
}
}
"path" -> {
bean.path = wsOpt.value.toString()
}
}
}
"grpc-opts", "grpc-opt" -> for (grpcOpt in (opt.value as Map<String, Any>)) {
when (grpcOpt.key.lowercase()) {
"grpc-service-name" -> bean.path =
grpcOpt.value.toString()
}
}
}
}
proxies.add(bean)
}
"wireguard" -> {
val peers = proxy["peers"] as? List<Map<String, Any?>>
val configToUse = peers?.firstOrNull() ?: proxy
val bean = WireGuardBean().apply {
name = proxy["name"].toString()
for ((key, value) in configToUse) {
when (key.replace("_", "-")) {
"server" -> serverAddress = value.toString()
"port" -> serverPort = value.toString().toIntOrNull() ?: 0
"mtu" -> mtu = value.toString().toIntOrNull() ?: 0
"ip" -> {
val ipValue = value.toString()
localAddress = if (!ipValue.contains("/")) {
"$ipValue/32"
} else {
ipValue
}
}
"ipv6" -> {
val ipv6Value = value.toString()
val processedIPv6Value = if (!ipv6Value.contains("/")) {
"$ipv6Value/128"
} else {
ipv6Value
}
if (localAddress.isNullOrEmpty()) {
localAddress = processedIPv6Value
} else {
localAddress += "\n$processedIPv6Value"
}
}
"private-key" -> privateKey = value.toString()
"public-key" -> peerPublicKey = value.toString()
"pre-shared-key", "preshared-key" -> peerPreSharedKey =
value.toString()
"reserved" -> {
val reservedValue = value
when (reservedValue) {
is List<*> -> {
if (reservedValue.size == 1) {
reserved = reservedValue[0].toString()
.replace("[\\[\\] ]".toRegex(), "")
} else {
reserved =
reservedValue.joinToString("\n") { it.toString() }
}
}
else -> {
reserved = reservedValue.toString()
.replace("[\\[\\] ]".toRegex(), "")
}
}
}
}
}
}
proxies.add(bean)
}
"hysteria" -> {
val bean = HysteriaBean()
bean.protocolVersion = 1
var hopPorts = ""
for (opt in proxy) {
if (opt.value == null) continue
when (opt.key.replace("_", "-")) {
"name" -> bean.name = opt.value.toString()
"server" -> bean.serverAddress = opt.value as String
"port" -> bean.serverPorts = opt.value.toString()
"ports" -> hopPorts = opt.value.toString()
"obfs" -> bean.obfuscation = opt.value.toString()
"auth-str" -> {
bean.authPayloadType = HysteriaBean.TYPE_STRING
bean.authPayload = opt.value.toString()
}
"sni" -> bean.sni = opt.value.toString()
"skip-cert-verify" -> bean.allowInsecure =
opt.value.toString() == "true"
"up" -> bean.uploadMbps =
opt.value.toString().substringBefore(" ").toIntOrNull()
?: 100
"down" -> bean.downloadMbps =
opt.value.toString().substringBefore(" ").toIntOrNull()
?: 100
"recv-window-conn" -> bean.connectionReceiveWindow =
opt.value.toString().toIntOrNull() ?: 0
"recv-window" -> bean.streamReceiveWindow =
opt.value.toString().toIntOrNull() ?: 0
"disable-mtu-discovery" -> bean.disableMtuDiscovery =
opt.value.toString() == "true" || opt.value.toString() == "1"
"alpn" -> {
val alpn = (opt.value as? (List<String>))
bean.alpn = alpn?.joinToString("\n") ?: "h3"
}
}
}
if (hopPorts.isNotBlank()) {
bean.serverPorts = hopPorts
}
proxies.add(bean)
}
"hysteria2" -> {
val bean = HysteriaBean()
bean.protocolVersion = 2
var hopPorts = ""
for (opt in proxy) {
if (opt.value == null) continue
when (opt.key.replace("_", "-")) {
"name" -> bean.name = opt.value.toString()
"server" -> bean.serverAddress = opt.value as String
"port" -> bean.serverPorts = opt.value.toString()
"ports" -> hopPorts = opt.value.toString()
"obfs-password" -> bean.obfuscation = opt.value.toString()
"password" -> bean.authPayload = opt.value.toString()
"sni" -> bean.sni = opt.value.toString()
"skip-cert-verify" -> bean.allowInsecure =
opt.value.toString() == "true"
"up" -> bean.uploadMbps =
opt.value.toString().substringBefore(" ").toIntOrNull() ?: 0
"down" -> bean.downloadMbps =
opt.value.toString().substringBefore(" ").toIntOrNull() ?: 0
}
}
if (hopPorts.isNotBlank()) {
bean.serverPorts = hopPorts
}
proxies.add(bean)
}
"tuic" -> {
val bean = TuicBean()
var ip = ""
for (opt in proxy) {
if (opt.value == null) continue
when (opt.key.replace("_", "-")) {
"name" -> bean.name = opt.value.toString()
"server" -> bean.serverAddress = opt.value.toString()
"ip" -> ip = opt.value.toString()
"port" -> bean.serverPort = opt.value.toString().toInt()
"token" -> {
bean.protocolVersion = 4
bean.token = opt.value.toString()
}
"uuid" -> bean.uuid = opt.value.toString()
"password" -> bean.token = opt.value.toString()
"skip-cert-verify" -> bean.allowInsecure =
opt.value.toString() == "true"
"disable-sni" -> bean.disableSNI =
opt.value.toString() == "true"
"reduce-rtt" -> bean.reduceRTT =
opt.value.toString() == "true"
"sni" -> bean.sni = opt.value.toString()
"alpn" -> {
val alpn = (opt.value as? (List<String>))
bean.alpn = alpn?.joinToString("\n")
}
"congestion-controller" -> bean.congestionController =
opt.value.toString()
"udp-relay-mode" -> bean.udpRelayMode = opt.value.toString()
"udp-over-stream" -> {
if (opt.value.toString() == "true") {
bean.udpRelayMode = "UDP over Stream"
}
}
}
}
if (ip.isNotBlank()) {
bean.serverAddress = ip
if (bean.sni.isNullOrBlank() && !bean.serverAddress.isNullOrBlank() && !bean.serverAddress.isIpAddress()) {
bean.sni = bean.serverAddress
}
}
proxies.add(bean)
}
}
}
// Fix ent
proxies.forEach {
it.initializeDefaultValues()
if (it is StandardV2RayBean) {
// 1. SNI
if (it.isTLS() && it.sni.isNullOrBlank() && !it.host.isNullOrBlank() && !it.host.isIpAddress()) {
it.sni = it.host
}
// 2. globalClientFingerprint
if (!it.realityPubKey.isNullOrBlank() && it.utlsFingerprint.isNullOrBlank()) {
it.utlsFingerprint = globalClientFingerprint
if (it.utlsFingerprint.isNullOrBlank()) it.utlsFingerprint = "chrome"
}
}
}
return proxies
} catch (e: YAMLException) {
Logs.w(e)
}
} else if (text.contains("[Interface]")) {
// wireguard
try {
proxies.addAll(parseWireGuard(text).map {
if (fileName.isNotBlank()) it.name = fileName.removeSuffix(".conf")
it
})
return proxies
} catch (e: Exception) {
Logs.w(e)
}
}
try {
val json = JSONTokener(text).nextValue()
return parseJSON(json)
} catch (ignored: Exception) {
}
try {
return parseProxies(text.decodeBase64UrlSafe()).takeIf { it.isNotEmpty() }
?: error("Not found")
} catch (e: Exception) {
Logs.w(e)
}
try {
return parseProxies(text).takeIf { it.isNotEmpty() } ?: error("Not found")
} catch (e: SubscriptionFoundException) {
throw e
} catch (ignored: Exception) {
}
return null
}
fun clashCipher(cipher: String): String {
return when (cipher) {
"dummy" -> "none"
else -> cipher
}
}
fun parseWireGuard(conf: String): List<WireGuardBean> {
val ini = Ini(StringReader(conf))
val iface = ini["Interface"] ?: error("Missing 'Interface' selection")
val bean = WireGuardBean().applyDefaultValues()
val localAddresses = iface.getAll("Address")
if (localAddresses.isNullOrEmpty()) error("Empty address in 'Interface' selection")
bean.localAddress = localAddresses.flatMap { it.split(",") }.joinToString("\n")
bean.privateKey = iface["PrivateKey"]
bean.mtu = iface["MTU"]?.toIntOrNull()
val peers = ini.getAll("Peer")
if (peers.isNullOrEmpty()) error("Missing 'Peer' selections")
val beans = mutableListOf<WireGuardBean>()
for (peer in peers) {
val endpoint = peer["Endpoint"]
if (endpoint.isNullOrBlank() || !endpoint.contains(":")) {
continue
}
val peerBean = bean.clone()
peerBean.serverAddress = endpoint.substringBeforeLast(":")
peerBean.serverPort = endpoint.substringAfterLast(":").toIntOrNull() ?: continue
peerBean.peerPublicKey = peer["PublicKey"] ?: continue
peerBean.peerPreSharedKey = peer["PresharedKey"]
beans.add(peerBean.applyDefaultValues())
}
if (beans.isEmpty()) error("Empty available peer list")
return beans
}
fun parseJSON(json: Any): List<AbstractBean> {
val proxies = ArrayList<AbstractBean>()
if (json is JSONObject) {
when {
json.has("server") && (json.has("up") || json.has("up_mbps")) -> {
return listOf(json.parseHysteria1Json())
}
json.has("method") -> {
return listOf(json.parseShadowsocks())
}
json.has("remote_addr") -> {
return listOf(json.parseTrojanGo())
}
json.has("outbounds") -> {
return listOf(ConfigBean().applyDefaultValues().apply {
config = json.toStringPretty()
})
}
json.has("server") && json.has("server_port") -> {
return listOf(ConfigBean().applyDefaultValues().apply {
type = 1
config = json.toStringPretty()
})
}
}
} else {
json as JSONArray
json.forEach { _, it ->
if (isJsonObjectValid(it)) {
proxies.addAll(parseJSON(it))
}
}
}
proxies.forEach { it.initializeDefaultValues() }
return proxies
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/group/RawUpdater.kt | 4208677712 |
package io.nekohasekai.sagernet.fmt
import io.nekohasekai.sagernet.database.ProxyEntity
object TypeMap : HashMap<String, Int>() {
init {
this["socks"] = ProxyEntity.TYPE_SOCKS
this["http"] = ProxyEntity.TYPE_HTTP
this["ss"] = ProxyEntity.TYPE_SS
this["vmess"] = ProxyEntity.TYPE_VMESS
this["trojan"] = ProxyEntity.TYPE_TROJAN
this["trojan-go"] = ProxyEntity.TYPE_TROJAN_GO
this["mieru"] = ProxyEntity.TYPE_MIERU
this["naive"] = ProxyEntity.TYPE_NAIVE
this["hysteria"] = ProxyEntity.TYPE_HYSTERIA
this["ssh"] = ProxyEntity.TYPE_SSH
this["wg"] = ProxyEntity.TYPE_WG
this["tuic"] = ProxyEntity.TYPE_TUIC
this["neko"] = ProxyEntity.TYPE_NEKO
this["config"] = ProxyEntity.TYPE_CONFIG
}
val reversed = HashMap<Int, String>()
init {
TypeMap.forEach { (key, type) ->
reversed[type] = key
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/TypeMap.kt | 2258149755 |
package io.nekohasekai.sagernet.fmt.trojan_go
import io.nekohasekai.sagernet.IPv6Mode
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.fmt.LOCALHOST
import io.nekohasekai.sagernet.ktx.*
import moe.matsuri.nb4a.Protocols
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import org.json.JSONArray
import org.json.JSONObject
fun parseTrojanGo(server: String): TrojanGoBean {
val link = server.replace("trojan-go://", "https://").toHttpUrlOrNull() ?: error(
"invalid trojan-link link $server"
)
return TrojanGoBean().apply {
serverAddress = link.host
serverPort = link.port
password = link.username
link.queryParameter("sni")?.let {
sni = it
}
link.queryParameter("type")?.let { lType ->
type = lType
when (type) {
"ws" -> {
link.queryParameter("host")?.let {
host = it
}
link.queryParameter("path")?.let {
path = it
}
}
else -> {
}
}
}
link.queryParameter("encryption")?.let {
encryption = it
}
link.queryParameter("plugin")?.let {
plugin = it
}
link.fragment.takeIf { !it.isNullOrBlank() }?.let {
name = it
}
}
}
fun TrojanGoBean.toUri(): String {
val builder = linkBuilder().username(password).host(serverAddress).port(serverPort)
if (sni.isNotBlank()) {
builder.addQueryParameter("sni", sni)
}
if (type.isNotBlank() && type != "original") {
builder.addQueryParameter("type", type)
when (type) {
"ws" -> {
if (host.isNotBlank()) {
builder.addQueryParameter("host", host)
}
if (path.isNotBlank()) {
builder.addQueryParameter("path", path)
}
}
}
}
if (type.isNotBlank() && type != "none") {
builder.addQueryParameter("encryption", encryption)
}
if (plugin.isNotBlank()) {
builder.addQueryParameter("plugin", plugin)
}
if (name.isNotBlank()) {
builder.encodedFragment(name.urlSafe())
}
return builder.toLink("trojan-go")
}
fun TrojanGoBean.buildTrojanGoConfig(port: Int): String {
return JSONObject().apply {
put("run_type", "client")
put("local_addr", LOCALHOST)
put("local_port", port)
put("remote_addr", finalAddress)
put("remote_port", finalPort)
put("password", JSONArray().apply {
put(password)
})
put("log_level", if (DataStore.logLevel > 0) 0 else 2)
if (Protocols.shouldEnableMux("trojan-go")) put("mux", JSONObject().apply {
put("enabled", true)
put("concurrency", DataStore.muxConcurrency)
})
put("tcp", JSONObject().apply {
put("prefer_ipv4", DataStore.ipv6Mode <= IPv6Mode.ENABLE)
})
when (type) {
"original" -> {
}
"ws" -> put("websocket", JSONObject().apply {
put("enabled", true)
put("host", host)
put("path", path)
})
}
if (sni.isBlank() && finalAddress == LOCALHOST && !serverAddress.isIpAddress()) {
sni = serverAddress
}
put("ssl", JSONObject().apply {
if (sni.isNotBlank()) put("sni", sni)
if (allowInsecure) put("verify", !(allowInsecure || DataStore.globalAllowInsecure))
})
when {
encryption == "none" -> {
}
encryption.startsWith("ss;") -> put("shadowsocks", JSONObject().apply {
put("enabled", true)
put("method", encryption.substringAfter(";").substringBefore(":"))
put("password", encryption.substringAfter(":"))
})
}
}.toStringPretty()
}
fun JSONObject.parseTrojanGo(): TrojanGoBean {
return TrojanGoBean().applyDefaultValues().apply {
serverAddress = optString("remote_addr", serverAddress)
serverPort = optInt("remote_port", serverPort)
when (val pass = get("password")) {
is String -> {
password = pass
}
is List<*> -> {
password = pass[0] as String
}
}
optJSONArray("ssl")?.apply {
sni = optString("sni", sni)
}
optJSONArray("websocket")?.apply {
if (optBoolean("enabled", false)) {
type = "ws"
host = optString("host", host)
path = optString("path", path)
}
}
optJSONArray("shadowsocks")?.apply {
if (optBoolean("enabled", false)) {
encryption = "ss;${optString("method", "")}:${optString("password", "")}"
}
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/trojan_go/TrojanGoFmt.kt | 2325706478 |
package io.nekohasekai.sagernet.fmt
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
enum class PluginEntry(
val pluginId: String,
val displayName: String,
val packageName: String, // for play and f-droid page
val downloadSource: DownloadSource = DownloadSource()
) {
TrojanGo(
"trojan-go-plugin",
SagerNet.application.getString(R.string.action_trojan_go),
"io.nekohasekai.sagernet.plugin.trojan_go"
),
NaiveProxy(
"naive-plugin",
SagerNet.application.getString(R.string.action_naive),
"io.nekohasekai.sagernet.plugin.naive",
DownloadSource(
playStore = false,
fdroid = false,
downloadLink = "https://github.com/AntiNeko/sing-plugin/releases?q=naive"
)
),
Hysteria(
"hysteria-plugin",
SagerNet.application.getString(R.string.action_hysteria),
"moe.matsuri.exe.hysteria",
DownloadSource(
playStore = false,
fdroid = false,
downloadLink = "https://github.com/MatsuriDayo/plugins/releases?q=Hysteria"
)
),
;
data class DownloadSource(
val playStore: Boolean = true,
val fdroid: Boolean = true,
val downloadLink: String = "https://AntiNeko.github.io/"
)
companion object {
fun find(name: String): PluginEntry? {
for (pluginEntry in enumValues<PluginEntry>()) {
if (name == pluginEntry.pluginId) {
return pluginEntry
}
}
return null
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/PluginEntry.kt | 2426876249 |
package io.nekohasekai.sagernet.fmt.v2ray
import android.text.TextUtils
import com.google.gson.Gson
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.fmt.http.HttpBean
import io.nekohasekai.sagernet.fmt.trojan.TrojanBean
import io.nekohasekai.sagernet.ktx.*
import moe.matsuri.nb4a.SingBoxOptions.*
import moe.matsuri.nb4a.utils.NGUtil
import moe.matsuri.nb4a.utils.listByLineOrComma
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrl
import org.json.JSONObject
data class VmessQRCode(
var v: String = "",
var ps: String = "",
var add: String = "",
var port: String = "",
var id: String = "",
var aid: String = "0",
var scy: String = "",
var net: String = "",
var packet_encoding: String = "",
var type: String = "",
var host: String = "",
var path: String = "",
var tls: String = "",
var sni: String = "",
var alpn: String = "",
var fp: String = "",
)
fun StandardV2RayBean.isTLS(): Boolean {
return security == "tls"
}
fun StandardV2RayBean.setTLS(boolean: Boolean) {
security = if (boolean) "tls" else ""
}
fun parseV2Ray(link: String): StandardV2RayBean {
// Try parse stupid formats first
if (!link.contains("?")) {
try {
return parseV2RayN(link)
} catch (e: Exception) {
Logs.i("try v2rayN: " + e.readableMessage)
}
}
try {
return tryResolveVmess4Kitsunebi(link)
} catch (e: Exception) {
Logs.i("try Kitsunebi: " + e.readableMessage)
}
// "std" format
val bean = VMessBean().apply { if (link.startsWith("vless://")) alterId = -1 }
val url = link.replace("vmess://", "https://").replace("vless://", "https://").toHttpUrl()
if (url.password.isNotBlank()) {
// https://github.com/v2fly/v2fly-github-io/issues/26 (rarely use)
bean.serverAddress = url.host
bean.serverPort = url.port
bean.name = url.fragment
var protocol = url.username
bean.type = protocol
bean.alterId = url.password.substringAfterLast('-').toInt()
bean.uuid = url.password.substringBeforeLast('-')
if (protocol.endsWith("+tls")) {
bean.security = "tls"
protocol = protocol.substring(0, protocol.length - 4)
url.queryParameter("tlsServerName")?.let {
if (it.isNotBlank()) {
bean.sni = it
}
}
}
when (protocol) {
// "tcp" -> {
// url.queryParameter("type")?.let { type ->
// if (type == "http") {
// bean.headerType = "http"
// url.queryParameter("host")?.let {
// bean.host = it
// }
// }
// }
// }
"http" -> {
url.queryParameter("path")?.let {
bean.path = it
}
url.queryParameter("host")?.let {
bean.host = it.split("|").joinToString(",")
}
}
"ws" -> {
url.queryParameter("path")?.let {
bean.path = it
}
url.queryParameter("host")?.let {
bean.host = it
}
}
"grpc" -> {
url.queryParameter("serviceName")?.let {
bean.path = it
}
}
"httpupgrade" -> {
url.queryParameter("path")?.let {
bean.path = it
}
url.queryParameter("host")?.let {
bean.host = it
}
}
}
bean.packetEncoding = 1 // It is comes from V2Ray!
} else {
// also vless format
bean.parseDuckSoft(url)
}
return bean
}
// https://github.com/XTLS/Xray-core/issues/91
fun StandardV2RayBean.parseDuckSoft(url: HttpUrl) {
serverAddress = url.host
serverPort = url.port
name = url.fragment
if (this is TrojanBean) {
password = url.username
} else {
uuid = url.username
}
// not ducksoft fmt path
if (url.pathSegments.size > 1 || url.pathSegments[0].isNotBlank()) {
path = url.pathSegments.joinToString("/")
}
type = url.queryParameter("type") ?: "tcp"
if (type == "h2") type = "http"
security = url.queryParameter("security")
if (security.isNullOrBlank()) {
security = if (this is TrojanBean) "tls" else "none"
}
when (security) {
"tls", "reality" -> {
security = "tls"
url.queryParameter("sni")?.let {
sni = it
}
url.queryParameter("host")?.let {
if (sni.isNullOrBlank()) sni = it
}
url.queryParameter("alpn")?.let {
alpn = it
}
url.queryParameter("cert")?.let {
certificates = it
}
url.queryParameter("pbk")?.let {
realityPubKey = it
}
url.queryParameter("sid")?.let {
realityShortId = it
}
}
}
when (type) {
"tcp" -> {
// v2rayNG
if (url.queryParameter("headerType") == "http") {
url.queryParameter("host")?.let {
type = "http"
host = it
}
}
}
"http" -> {
url.queryParameter("host")?.let {
host = it
}
url.queryParameter("path")?.let {
path = it
}
}
"ws" -> {
url.queryParameter("host")?.let {
host = it
}
url.queryParameter("path")?.let {
path = it
}
url.queryParameter("ed")?.let { ed ->
wsMaxEarlyData = ed.toInt()
url.queryParameter("eh")?.let {
earlyDataHeaderName = it
}
}
}
"grpc" -> {
url.queryParameter("serviceName")?.let {
path = it
}
}
"httpupgrade" -> {
url.queryParameter("host")?.let {
host = it
}
url.queryParameter("path")?.let {
path = it
}
}
}
// maybe from matsuri vmess exoprt
if (this is VMessBean && !isVLESS) {
url.queryParameter("encryption")?.let {
encryption = it
}
}
if (isVLESS) {
url.queryParameter("packetEncoding")?.let {
when (it) {
"packetaddr" -> packetEncoding = 1
"xudp" -> packetEncoding = 2
}
}
}
url.queryParameter("flow")?.let {
if (isVLESS) {
encryption = it.removeSuffix("-udp443")
}
}
url.queryParameter("fp")?.let {
utlsFingerprint = it
}
}
// 不确定是谁的格式
private fun tryResolveVmess4Kitsunebi(server: String): VMessBean {
// vmess://YXV0bzo1YWY1ZDBlYy02ZWEwLTNjNDMtOTNkYi1jYTMwMDg1MDNiZGJAMTgzLjIzMi41Ni4xNjE6MTIwMg
// ?remarks=*%F0%9F%87%AF%F0%9F%87%B5JP%20-355%20TG@moon365free&obfsParam=%7B%22Host%22:%22183.232.56.161%22%7D&path=/v2ray&obfs=websocket&alterId=0
var result = server.replace("vmess://", "")
val indexSplit = result.indexOf("?")
if (indexSplit > 0) {
result = result.substring(0, indexSplit)
}
result = NGUtil.decode(result)
val arr1 = result.split('@')
if (arr1.count() != 2) {
throw IllegalStateException("invalid kitsunebi format")
}
val arr21 = arr1[0].split(':')
val arr22 = arr1[1].split(':')
if (arr21.count() != 2) {
throw IllegalStateException("invalid kitsunebi format")
}
return VMessBean().apply {
serverAddress = arr22[0]
serverPort = NGUtil.parseInt(arr22[1])
uuid = arr21[1]
encryption = arr21[0]
if (indexSplit < 0) return@apply
val url = ("https://localhost/path?" + server.substringAfter("?")).toHttpUrl()
url.queryParameter("remarks")?.apply { name = this }
url.queryParameter("alterId")?.apply { alterId = this.toInt() }
url.queryParameter("path")?.apply { path = this }
url.queryParameter("tls")?.apply { security = "tls" }
url.queryParameter("allowInsecure")
?.apply { if (this == "1" || this == "true") allowInsecure = true }
url.queryParameter("obfs")?.apply {
type = this.replace("websocket", "ws").replace("none", "tcp")
if (type == "ws") {
url.queryParameter("obfsParam")?.apply {
if (this.startsWith("{")) {
host = JSONObject(this).getStr("Host")
} else if (security == "tls") {
sni = this
}
}
}
}
}
}
// SagerNet's
// Do not support some format and then throw exception
fun parseV2RayN(link: String): VMessBean {
val result = link.substringAfter("vmess://").decodeBase64UrlSafe()
if (result.contains("= vmess")) {
return parseCsvVMess(result)
}
val bean = VMessBean()
val vmessQRCode = Gson().fromJson(result, VmessQRCode::class.java)
// Although VmessQRCode fields are non null, looks like Gson may still create null fields
if (TextUtils.isEmpty(vmessQRCode.add)
|| TextUtils.isEmpty(vmessQRCode.port)
|| TextUtils.isEmpty(vmessQRCode.id)
|| TextUtils.isEmpty(vmessQRCode.net)
) {
throw Exception("invalid VmessQRCode")
}
bean.name = vmessQRCode.ps
bean.serverAddress = vmessQRCode.add
bean.serverPort = vmessQRCode.port.toIntOrNull()
bean.encryption = vmessQRCode.scy
bean.uuid = vmessQRCode.id
bean.alterId = vmessQRCode.aid.toIntOrNull()
bean.type = vmessQRCode.net
bean.host = vmessQRCode.host
bean.path = vmessQRCode.path
val headerType = vmessQRCode.type
when (vmessQRCode.packet_encoding) {
"packetaddr" -> {
bean.packetEncoding = 1
}
"xudp" -> {
bean.packetEncoding = 2
}
}
when (bean.type) {
"tcp" -> {
if (headerType == "http") {
bean.type = "http"
}
}
}
when (vmessQRCode.tls) {
"tls", "reality" -> {
bean.security = "tls"
bean.sni = vmessQRCode.sni
if (bean.sni.isNullOrBlank()) bean.sni = bean.host
bean.alpn = vmessQRCode.alpn
bean.utlsFingerprint = vmessQRCode.fp
}
}
return bean
}
private fun parseCsvVMess(csv: String): VMessBean {
val args = csv.split(",")
val bean = VMessBean()
bean.serverAddress = args[1]
bean.serverPort = args[2].toInt()
bean.encryption = args[3]
bean.uuid = args[4].replace("\"", "")
args.subList(5, args.size).forEach {
when {
it == "over-tls=true" -> bean.security = "tls"
it.startsWith("tls-host=") -> bean.host = it.substringAfter("=")
it.startsWith("obfs=") -> bean.type = it.substringAfter("=")
it.startsWith("obfs-path=") || it.contains("Host:") -> {
runCatching {
bean.path = it.substringAfter("obfs-path=\"").substringBefore("\"obfs")
}
runCatching {
bean.host = it.substringAfter("Host:").substringBefore("[")
}
}
}
}
return bean
}
fun VMessBean.toV2rayN(): String {
val bean = this
return "vmess://" + VmessQRCode().apply {
v = "2"
ps = bean.name
add = bean.serverAddress
port = bean.serverPort.toString()
id = bean.uuid
aid = bean.alterId.toString()
net = bean.type
when (bean.packetEncoding) {
0 -> packet_encoding = ""
1 -> packet_encoding = "packetaddr"
2 -> packet_encoding = "xudp"
}
host = bean.host
path = bean.path
when (net) {
"http" -> {
if (!isTLS()) {
type = "http"
net = "tcp"
}
}
}
if (isTLS()) {
tls = "tls"
if (bean.realityPubKey.isNotBlank()) {
tls = "reality"
}
}
scy = bean.encryption
sni = bean.sni
alpn = bean.alpn.replace("\n", ",")
fp = bean.utlsFingerprint
}.let {
NGUtil.encode(Gson().toJson(it))
}
}
fun StandardV2RayBean.toUriVMessVLESSTrojan(isTrojan: Boolean): String {
// VMess
if (this is VMessBean && !isVLESS) {
return toV2rayN()
}
// VLESS & Trojan (ducksoft fmt)
val builder = linkBuilder()
.username(if (this is TrojanBean) password else uuid)
.host(serverAddress)
.port(serverPort)
.addQueryParameter("type", type)
if (isVLESS) {
builder.addQueryParameter("encryption", "none")
if (encryption != "auto") builder.addQueryParameter("flow", encryption)
when (packetEncoding) {
1 -> {
builder.addQueryParameter("packetEncoding", "packetaddr")
}
2 -> {
builder.addQueryParameter("packetEncoding", "xudp")
}
}
}
when (type) {
"tcp" -> {}
"ws", "http", "httpupgrade" -> {
if (host.isNotBlank()) {
builder.addQueryParameter("host", host)
}
if (path.isNotBlank()) {
builder.addQueryParameter("path", path)
}
if (type == "ws") {
if (wsMaxEarlyData > 0) {
builder.addQueryParameter("ed", "$wsMaxEarlyData")
if (earlyDataHeaderName.isNotBlank()) {
builder.addQueryParameter("eh", earlyDataHeaderName)
}
}
} else if (type == "http" && !isTLS()) {
builder.setQueryParameter("type", "tcp")
builder.addQueryParameter("headerType", "http")
}
}
"grpc" -> {
if (path.isNotBlank()) {
builder.setQueryParameter("serviceName", path)
}
}
}
if (security.isNotBlank() && security != "none") {
builder.addQueryParameter("security", security)
when (security) {
"tls" -> {
if (sni.isNotBlank()) {
builder.addQueryParameter("sni", sni)
}
if (alpn.isNotBlank()) {
builder.addQueryParameter("alpn", alpn.replace("\n", ","))
}
if (certificates.isNotBlank()) {
builder.addQueryParameter("cert", certificates)
}
if (allowInsecure) {
builder.addQueryParameter("allowInsecure", "1")
}
if (utlsFingerprint.isNotBlank()) {
builder.addQueryParameter("fp", utlsFingerprint)
}
if (realityPubKey.isNotBlank()) {
builder.setQueryParameter("security", "reality")
builder.addQueryParameter("pbk", realityPubKey)
builder.addQueryParameter("sid", realityShortId)
}
}
}
}
if (name.isNotBlank()) {
builder.encodedFragment(name.urlSafe())
}
return builder.toLink(if (isTrojan) "trojan" else "vless")
}
fun buildSingBoxOutboundStreamSettings(bean: StandardV2RayBean): V2RayTransportOptions? {
when (bean.type) {
"tcp" -> {
return null
}
"ws" -> {
return V2RayTransportOptions_WebsocketOptions().apply {
type = "ws"
headers = mutableMapOf()
if (bean.host.isNotBlank()) {
headers["Host"] = bean.host
}
if (bean.path.contains("?ed=")) {
path = bean.path.substringBefore("?ed=")
max_early_data = bean.path.substringAfter("?ed=").toIntOrNull() ?: 2048
early_data_header_name = "Sec-WebSocket-Protocol"
} else {
path = bean.path.takeIf { it.isNotBlank() } ?: "/"
}
if (bean.wsMaxEarlyData > 0) {
max_early_data = bean.wsMaxEarlyData
}
if (bean.earlyDataHeaderName.isNotBlank()) {
early_data_header_name = bean.earlyDataHeaderName
}
}
}
"http" -> {
return V2RayTransportOptions_HTTPOptions().apply {
type = "http"
if (!bean.isTLS()) method = "GET" // v2ray tcp header
if (bean.host.isNotBlank()) {
host = bean.host.split(",")
}
path = bean.path.takeIf { it.isNotBlank() } ?: "/"
}
}
"quic" -> {
return V2RayTransportOptions().apply {
type = "quic"
}
}
"grpc" -> {
return V2RayTransportOptions_GRPCOptions().apply {
type = "grpc"
service_name = bean.path
}
}
"httpupgrade" -> {
return V2RayTransportOptions_HTTPUpgradeOptions().apply {
type = "httpupgrade"
host = bean.host
path = bean.path
}
}
}
// if (needKeepAliveInterval) {
// sockopt = StreamSettingsObject.SockoptObject().apply {
// tcpKeepAliveInterval = keepAliveInterval
// }
// }
return null
}
fun buildSingBoxOutboundTLS(bean: StandardV2RayBean): OutboundTLSOptions? {
if (bean.security != "tls") return null
return OutboundTLSOptions().apply {
enabled = true
insecure = bean.allowInsecure || DataStore.globalAllowInsecure
if (bean.sni.isNotBlank()) server_name = bean.sni
if (bean.alpn.isNotBlank()) alpn = bean.alpn.listByLineOrComma()
if (bean.certificates.isNotBlank()) certificate = bean.certificates
var fp = bean.utlsFingerprint
if (bean.realityPubKey.isNotBlank()) {
reality = OutboundRealityOptions().apply {
enabled = true
public_key = bean.realityPubKey
short_id = bean.realityShortId
}
if (fp.isNullOrBlank()) fp = "chrome"
}
if (fp.isNotBlank()) {
utls = OutboundUTLSOptions().apply {
enabled = true
fingerprint = fp
}
}
if (bean.ech) {
val echList = bean.echCfg.split("\n")
ech = OutboundECHOptions().apply {
enabled = true
pq_signature_schemes_enabled = echList.size > 5
dynamic_record_sizing_disabled = true
config = echList
}
}
}
}
fun buildSingBoxOutboundStandardV2RayBean(bean: StandardV2RayBean): Outbound {
when (bean) {
is HttpBean -> {
return Outbound_HTTPOptions().apply {
type = "http"
server = bean.serverAddress
server_port = bean.serverPort
username = bean.username
password = bean.password
tls = buildSingBoxOutboundTLS(bean)
}
}
is VMessBean -> {
if (bean.isVLESS) return Outbound_VLESSOptions().apply {
type = "vless"
server = bean.serverAddress
server_port = bean.serverPort
uuid = bean.uuid
if (bean.encryption.isNotBlank() && bean.encryption != "auto") {
flow = bean.encryption
}
when (bean.packetEncoding) {
0 -> packet_encoding = ""
1 -> packet_encoding = "packetaddr"
2 -> packet_encoding = "xudp"
}
tls = buildSingBoxOutboundTLS(bean)
transport = buildSingBoxOutboundStreamSettings(bean)
}
return Outbound_VMessOptions().apply {
type = "vmess"
server = bean.serverAddress
server_port = bean.serverPort
uuid = bean.uuid
alter_id = bean.alterId
security = bean.encryption.takeIf { it.isNotBlank() } ?: "auto"
when (bean.packetEncoding) {
0 -> packet_encoding = ""
1 -> packet_encoding = "packetaddr"
2 -> packet_encoding = "xudp"
}
tls = buildSingBoxOutboundTLS(bean)
transport = buildSingBoxOutboundStreamSettings(bean)
}
}
is TrojanBean -> {
return Outbound_TrojanOptions().apply {
type = "trojan"
server = bean.serverAddress
server_port = bean.serverPort
password = bean.password
tls = buildSingBoxOutboundTLS(bean)
transport = buildSingBoxOutboundStreamSettings(bean)
}
}
else -> throw IllegalStateException("can't reach")
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/v2ray/V2RayFmt.kt | 2054703880 |
package io.nekohasekai.sagernet.fmt.trojan
import io.nekohasekai.sagernet.fmt.v2ray.parseDuckSoft
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
fun parseTrojan(server: String): TrojanBean {
val link = server.replace("trojan://", "https://").toHttpUrlOrNull()
?: error("invalid trojan link $server")
return TrojanBean().apply {
parseDuckSoft(link)
link.queryParameter("allowInsecure")
?.apply { if (this == "1" || this == "true") allowInsecure = true }
link.queryParameter("peer")?.apply { if (this.isNotBlank()) sni = this }
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/trojan/TrojanFmt.kt | 42228517 |
package io.nekohasekai.sagernet.fmt
import android.widget.Toast
import io.nekohasekai.sagernet.*
import io.nekohasekai.sagernet.bg.VpnService
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.ProxyEntity
import io.nekohasekai.sagernet.database.ProxyEntity.Companion.TYPE_CONFIG
import io.nekohasekai.sagernet.database.SagerDatabase
import io.nekohasekai.sagernet.fmt.ConfigBuildResult.IndexEntity
import io.nekohasekai.sagernet.fmt.hysteria.HysteriaBean
import io.nekohasekai.sagernet.fmt.hysteria.buildSingBoxOutboundHysteriaBean
import io.nekohasekai.sagernet.fmt.internal.ChainBean
import io.nekohasekai.sagernet.fmt.shadowsocks.ShadowsocksBean
import io.nekohasekai.sagernet.fmt.shadowsocks.buildSingBoxOutboundShadowsocksBean
import io.nekohasekai.sagernet.fmt.socks.SOCKSBean
import io.nekohasekai.sagernet.fmt.socks.buildSingBoxOutboundSocksBean
import io.nekohasekai.sagernet.fmt.ssh.SSHBean
import io.nekohasekai.sagernet.fmt.ssh.buildSingBoxOutboundSSHBean
import io.nekohasekai.sagernet.fmt.tuic.TuicBean
import io.nekohasekai.sagernet.fmt.tuic.buildSingBoxOutboundTuicBean
import io.nekohasekai.sagernet.fmt.v2ray.StandardV2RayBean
import io.nekohasekai.sagernet.fmt.v2ray.buildSingBoxOutboundStandardV2RayBean
import io.nekohasekai.sagernet.fmt.wireguard.WireGuardBean
import io.nekohasekai.sagernet.fmt.wireguard.buildSingBoxOutboundWireguardBean
import io.nekohasekai.sagernet.ktx.isIpAddress
import io.nekohasekai.sagernet.ktx.mkPort
import io.nekohasekai.sagernet.utils.PackageCache
import moe.matsuri.nb4a.*
import moe.matsuri.nb4a.SingBoxOptions.*
import moe.matsuri.nb4a.plugin.Plugins
import moe.matsuri.nb4a.proxy.config.ConfigBean
import moe.matsuri.nb4a.proxy.shadowtls.ShadowTLSBean
import moe.matsuri.nb4a.proxy.shadowtls.buildSingBoxOutboundShadowTLSBean
import moe.matsuri.nb4a.utils.JavaUtil.gson
import moe.matsuri.nb4a.utils.Util
import moe.matsuri.nb4a.utils.listByLineOrComma
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
const val TAG_MIXED = "mixed-in"
const val TAG_PROXY = "proxy"
const val TAG_DIRECT = "direct"
const val TAG_BYPASS = "bypass"
const val TAG_BLOCK = "block"
const val TAG_DNS_IN = "dns-in"
const val TAG_DNS_OUT = "dns-out"
const val LOCALHOST = "127.0.0.1"
const val LOCAL_DNS_SERVER = "local"
// TODO kill this poop
val externalAssets = SagerNet.application.externalAssets.absolutePath
class ConfigBuildResult(
var config: String,
var externalIndex: List<IndexEntity>,
var mainEntId: Long,
var trafficMap: Map<String, List<ProxyEntity>>,
var profileTagMap: Map<Long, String>,
val selectorGroupId: Long,
) {
data class IndexEntity(var chain: LinkedHashMap<Int, ProxyEntity>)
}
fun buildConfig(
proxy: ProxyEntity, forTest: Boolean = false, forExport: Boolean = false
): ConfigBuildResult {
if (proxy.type == TYPE_CONFIG) {
val bean = proxy.requireBean() as ConfigBean
if (bean.type == 0) {
return ConfigBuildResult(
bean.config,
listOf(),
proxy.id, //
mapOf(TAG_PROXY to listOf(proxy)), //
mapOf(proxy.id to TAG_PROXY), //
-1L
)
}
}
val trafficMap = HashMap<String, List<ProxyEntity>>()
val tagMap = HashMap<Long, String>()
val globalOutbounds = HashMap<Long, String>()
val selectorNames = ArrayList<String>()
val group = SagerDatabase.groupDao.getById(proxy.groupId)
val optionsToMerge = proxy.requireBean().customConfigJson ?: ""
fun ProxyEntity.resolveChainInternal(): MutableList<ProxyEntity> {
val bean = requireBean()
if (bean is ChainBean) {
val beans = SagerDatabase.proxyDao.getEntities(bean.proxies)
val beansMap = beans.associateBy { it.id }
val beanList = ArrayList<ProxyEntity>()
for (proxyId in bean.proxies) {
val item = beansMap[proxyId] ?: continue
beanList.addAll(item.resolveChainInternal())
}
return beanList.asReversed()
}
return mutableListOf(this)
}
fun selectorName(name_: String): String {
var name = name_
var count = 0
while (selectorNames.contains(name)) {
count++
name = "$name_-$count"
}
selectorNames.add(name)
return name
}
fun ProxyEntity.resolveChain(): MutableList<ProxyEntity> {
val thisGroup = SagerDatabase.groupDao.getById(groupId)
val frontProxy = thisGroup?.frontProxy?.let { SagerDatabase.proxyDao.getById(it) }
val landingProxy = thisGroup?.landingProxy?.let { SagerDatabase.proxyDao.getById(it) }
val list = resolveChainInternal()
if (frontProxy != null) {
list.add(frontProxy)
}
if (landingProxy != null) {
list.add(0, landingProxy)
}
return list
}
val extraRules = if (forTest) listOf() else SagerDatabase.rulesDao.enabledRules()
val extraProxies =
if (forTest) mapOf() else SagerDatabase.proxyDao.getEntities(extraRules.mapNotNull { rule ->
rule.outbound.takeIf { it > 0 && it != proxy.id }
}.toHashSet().toList()).associateBy { it.id }
val buildSelector = !forTest && group?.isSelector == true && !forExport
val userDNSRuleList = mutableListOf<DNSRule_DefaultOptions>()
val domainListDNSDirectForce = mutableListOf<String>()
val bypassDNSBeans = hashSetOf<AbstractBean>()
val isVPN = DataStore.serviceMode == Key.MODE_VPN
val bind = if (!forTest && DataStore.allowAccess) "0.0.0.0" else LOCALHOST
val remoteDns = DataStore.remoteDns.split("\n")
.mapNotNull { dns -> dns.trim().takeIf { it.isNotBlank() && !it.startsWith("#") } }
val directDNS = DataStore.directDns.split("\n")
.mapNotNull { dns -> dns.trim().takeIf { it.isNotBlank() && !it.startsWith("#") } }
val underlyingDns = DataStore.underlyingDns.split("\n")
.mapNotNull { dns -> dns.trim().takeIf { it.isNotBlank() && !it.startsWith("#") } }
val enableDnsRouting = DataStore.enableDnsRouting
val useFakeDns = DataStore.enableFakeDns && !forTest
val needSniff = DataStore.trafficSniffing > 0
val needSniffOverride = DataStore.trafficSniffing == 2
val externalIndexMap = ArrayList<IndexEntity>()
val ipv6Mode = if (forTest) IPv6Mode.ENABLE else DataStore.ipv6Mode
fun genDomainStrategy(noAsIs: Boolean): String {
return when {
!noAsIs -> ""
ipv6Mode == IPv6Mode.DISABLE -> "ipv4_only"
ipv6Mode == IPv6Mode.PREFER -> "prefer_ipv6"
ipv6Mode == IPv6Mode.ONLY -> "ipv6_only"
else -> "prefer_ipv4"
}
}
return MyOptions().apply {
if (!forTest) experimental = ExperimentalOptions().apply {
clash_api = ClashAPIOptions().apply {
external_controller = DataStore.clashAPIListen
external_ui = "../files/dashboard"
}
cache_file = CacheFileOptions().apply {
enabled = true
path = "../cache/clash.db"
}
}
log = LogOptions().apply {
level = when (DataStore.logLevel) {
0 -> "panic"
1 -> "fatal"
2 -> "error"
3 -> "warn"
4 -> "info"
5 -> "debug"
6 -> "trace"
else -> "info"
}
}
dns = DNSOptions().apply {
// TODO nb4a hosts?
// hosts = DataStore.hosts.split("\n")
// .filter { it.isNotBlank() }
// .associate { it.substringBefore(" ") to it.substringAfter(" ") }
// .toMutableMap()
servers = mutableListOf()
rules = mutableListOf()
independent_cache = true
}
fun autoDnsDomainStrategy(s: String): String? {
if (s.isNotEmpty()) {
return s
}
return when (ipv6Mode) {
IPv6Mode.DISABLE -> "ipv4_only"
IPv6Mode.ENABLE -> "prefer_ipv4"
IPv6Mode.PREFER -> "prefer_ipv6"
IPv6Mode.ONLY -> "ipv6_only"
else -> null
}
}
inbounds = mutableListOf()
if (!forTest) {
if (isVPN) inbounds.add(Inbound_TunOptions().apply {
type = "tun"
tag = "tun-in"
stack = when (DataStore.tunImplementation) {
TunImplementation.GVISOR -> "gvisor"
TunImplementation.SYSTEM -> "system"
else -> "mixed"
}
endpoint_independent_nat = true
mtu = DataStore.mtu
domain_strategy = genDomainStrategy(DataStore.resolveDestination)
sniff = needSniff
sniff_override_destination = needSniffOverride
when (ipv6Mode) {
IPv6Mode.DISABLE -> {
inet4_address = listOf(VpnService.PRIVATE_VLAN4_CLIENT + "/28")
}
IPv6Mode.ONLY -> {
inet6_address = listOf(VpnService.PRIVATE_VLAN6_CLIENT + "/126")
}
else -> {
inet4_address = listOf(VpnService.PRIVATE_VLAN4_CLIENT + "/28")
inet6_address = listOf(VpnService.PRIVATE_VLAN6_CLIENT + "/126")
}
}
})
inbounds.add(Inbound_MixedOptions().apply {
type = "mixed"
tag = TAG_MIXED
listen = bind
listen_port = DataStore.mixedPort
domain_strategy = genDomainStrategy(DataStore.resolveDestination)
sniff = needSniff
sniff_override_destination = needSniffOverride
if (!DataStore.inboundUsername.isNullOrEmpty() || !DataStore.inboundPassword.isNullOrEmpty()) {
users = listOf(
User().apply {
username = DataStore.inboundUsername
password = DataStore.inboundPassword
}
)
}
})
}
outbounds = mutableListOf()
// init routing object
route = RouteOptions().apply {
auto_detect_interface = true
rules = mutableListOf()
rule_set = mutableListOf()
}
// returns outbound tag
fun buildChain(
chainId: Long, entity: ProxyEntity
): String {
val profileList = entity.resolveChain()
val chainTrafficSet = HashSet<ProxyEntity>().apply {
plusAssign(profileList)
add(entity)
}
var currentOutbound = mutableMapOf<String, Any>()
lateinit var pastOutbound: MutableMap<String, Any>
lateinit var pastInboundTag: String
var pastEntity: ProxyEntity? = null
val externalChainMap = LinkedHashMap<Int, ProxyEntity>()
externalIndexMap.add(IndexEntity(externalChainMap))
val chainOutbounds = ArrayList<MutableMap<String, Any>>()
// chainTagOut: v2ray outbound tag for this chain
var chainTagOut = ""
val chainTag = "c-$chainId"
var muxApplied = false
val defaultServerDomainStrategy = SingBoxOptionsUtil.domainStrategy("server")
profileList.forEachIndexed { index, proxyEntity ->
val bean = proxyEntity.requireBean()
// tagOut: v2ray outbound tag for a profile
// profile2 (in) (global) tag g-(id)
// profile1 tag (chainTag)-(id)
// profile0 (out) tag (chainTag)-(id) / single: "proxy"
var tagOut = "$chainTag-${proxyEntity.id}"
// needGlobal: can only contain one?
var needGlobal = false
// first profile set as global
if (index == profileList.lastIndex) {
needGlobal = true
tagOut = "g-" + proxyEntity.id
bypassDNSBeans += proxyEntity.requireBean()
}
// last profile set as "proxy"
if (chainId == 0L && index == 0) {
tagOut = TAG_PROXY
}
// selector human readable name
if (buildSelector && index == 0) {
tagOut = selectorName(bean.displayName())
}
// chain rules
if (index > 0) {
// chain route/proxy rules
if (pastEntity!!.needExternal()) {
route.rules.add(Rule_DefaultOptions().apply {
inbound = listOf(pastInboundTag)
outbound = tagOut
})
} else {
pastOutbound["detour"] = tagOut
}
} else {
// index == 0 means last profile in chain / not chain
chainTagOut = tagOut
}
// now tagOut is determined
if (needGlobal) {
globalOutbounds[proxyEntity.id]?.let {
if (index == 0) chainTagOut = it // single, duplicate chain
return@forEachIndexed
}
globalOutbounds[proxyEntity.id] = tagOut
}
if (proxyEntity.needExternal()) { // externel outbound
val localPort = mkPort()
externalChainMap[localPort] = proxyEntity
currentOutbound = Outbound_SocksOptions().apply {
type = "socks"
server = LOCALHOST
server_port = localPort
}.asMap()
} else { // internal outbound
currentOutbound = when (bean) {
is ConfigBean ->
gson.fromJson(bean.config, currentOutbound.javaClass)
is ShadowTLSBean -> // before StandardV2RayBean
buildSingBoxOutboundShadowTLSBean(bean).asMap()
is StandardV2RayBean -> // http/trojan/vmess/vless
buildSingBoxOutboundStandardV2RayBean(bean).asMap()
is HysteriaBean ->
buildSingBoxOutboundHysteriaBean(bean)
is TuicBean ->
buildSingBoxOutboundTuicBean(bean).asMap()
is SOCKSBean ->
buildSingBoxOutboundSocksBean(bean).asMap()
is ShadowsocksBean ->
buildSingBoxOutboundShadowsocksBean(bean).asMap()
is WireGuardBean ->
buildSingBoxOutboundWireguardBean(bean).asMap()
is SSHBean ->
buildSingBoxOutboundSSHBean(bean).asMap()
else -> throw IllegalStateException("can't reach")
}
currentOutbound.apply {
// TODO nb4a keepAliveInterval?
// val keepAliveInterval = DataStore.tcpKeepAliveInterval
// val needKeepAliveInterval = keepAliveInterval !in intArrayOf(0, 15)
if (!muxApplied && proxyEntity.needCoreMux()) {
muxApplied = true
currentOutbound["multiplex"] = MultiplexOptions().apply {
enabled = true
padding = Protocols.shouldEnableMux("padding")
max_streams = DataStore.muxConcurrency
protocol = when (DataStore.muxType) {
1 -> "smux"
2 -> "yamux"
else -> "h2mux"
}
}.asMap()
}
}
}
// internal & external
currentOutbound.apply {
// udp over tcp
try {
val sUoT = bean.javaClass.getField("sUoT").get(bean)
if (sUoT is Boolean && sUoT == true) {
currentOutbound["udp_over_tcp"] = true
}
} catch (_: Exception) {
}
// domain_strategy
pastEntity?.requireBean()?.apply {
// don't loopback
if (defaultServerDomainStrategy != "" && !serverAddress.isIpAddress()) {
domainListDNSDirectForce.add("full:$serverAddress")
}
}
currentOutbound["domain_strategy"] =
if (forTest) "" else defaultServerDomainStrategy
// custom JSON merge
if (bean.customOutboundJson.isNotBlank()) {
Util.mergeJSON(bean.customOutboundJson, currentOutbound)
}
}
currentOutbound["tag"] = tagOut
// External proxy need a dokodemo-door inbound to forward the traffic
// For external proxy software, their traffic must goes to v2ray-core to use protected fd.
bean.finalAddress = bean.serverAddress
bean.finalPort = bean.serverPort
if (bean.canMapping() && proxyEntity.needExternal()) {
// With ss protect, don't use mapping
var needExternal = true
if (index == profileList.lastIndex) {
val pluginId = when (bean) {
is HysteriaBean -> if (bean.protocolVersion == 1) "hysteria-plugin" else "hysteria2-plugin"
else -> ""
}
if (Plugins.isUsingMatsuriExe(pluginId)) {
needExternal = false
} else if (Plugins.getPluginExternal(pluginId) != null) {
throw Exception("You are using an unsupported $pluginId, please download the correct plugin.")
}
}
if (needExternal) {
val mappingPort = mkPort()
bean.finalAddress = LOCALHOST
bean.finalPort = mappingPort
inbounds.add(Inbound_DirectOptions().apply {
type = "direct"
listen = LOCALHOST
listen_port = mappingPort
tag = "$chainTag-mapping-${proxyEntity.id}"
override_address = bean.serverAddress
override_port = bean.serverPort
pastInboundTag = tag
// no chain rule and not outbound, so need to set to direct
if (index == profileList.lastIndex) {
route.rules.add(Rule_DefaultOptions().apply {
inbound = listOf(tag)
outbound = TAG_DIRECT
})
}
})
}
}
outbounds.add(currentOutbound)
chainOutbounds.add(currentOutbound)
pastOutbound = currentOutbound
pastEntity = proxyEntity
}
trafficMap[chainTagOut] = chainTrafficSet.toList()
return chainTagOut
}
// build outbounds
if (buildSelector) {
val list = group?.id?.let { SagerDatabase.proxyDao.getByGroup(it) }
list?.forEach {
tagMap[it.id] = buildChain(it.id, it)
}
outbounds.add(0, Outbound_SelectorOptions().apply {
type = "selector"
tag = TAG_PROXY
default_ = tagMap[proxy.id]
outbounds = tagMap.values.toList()
}.asMap())
} else {
buildChain(0, proxy)
}
// build outbounds from route item
extraProxies.forEach { (key, p) ->
tagMap[key] = buildChain(key, p)
}
// apply user rules
for (rule in extraRules) {
if (rule.packages.isNotEmpty()) {
PackageCache.awaitLoadSync()
}
val uidList = rule.packages.map {
if (!isVPN) {
Toast.makeText(
SagerNet.application,
SagerNet.application.getString(R.string.route_need_vpn, rule.displayName()),
Toast.LENGTH_SHORT
).show()
}
PackageCache[it]?.takeIf { uid -> uid >= 1000 }
}.toHashSet().filterNotNull()
val ruleObj = Rule_DefaultOptions().apply {
if (uidList.isNotEmpty()) {
PackageCache.awaitLoadSync()
user_id = uidList
}
var domainList: List<String>? = null
if (rule.domains.isNotBlank()) {
domainList = rule.domains.listByLineOrComma()
makeSingBoxRule(domainList, false)
}
if (rule.ip.isNotBlank()) {
makeSingBoxRule(rule.ip.listByLineOrComma(), true)
}
if (rule.port.isNotBlank()) {
port = mutableListOf<Int>()
port_range = mutableListOf<String>()
rule.port.listByLineOrComma().map {
if (it.contains(":")) {
port_range.add(it)
} else {
it.toIntOrNull()?.apply { port.add(this) }
}
}
}
if (rule.sourcePort.isNotBlank()) {
source_port = mutableListOf<Int>()
source_port_range = mutableListOf<String>()
rule.sourcePort.listByLineOrComma().map {
if (it.contains(":")) {
source_port_range.add(it)
} else {
it.toIntOrNull()?.apply { source_port.add(this) }
}
}
}
if (rule.network.isNotBlank()) {
network = listOf(rule.network)
}
if (rule.source.isNotBlank()) {
source_ip_cidr = rule.source.listByLineOrComma()
}
if (rule.protocol.isNotBlank()) {
protocol = rule.protocol.listByLineOrComma()
}
fun makeDnsRuleObj(): DNSRule_DefaultOptions {
return DNSRule_DefaultOptions().apply {
if (uidList.isNotEmpty()) user_id = uidList
domainList?.let { makeSingBoxRule(it) }
}
}
when (rule.outbound) {
-1L -> {
userDNSRuleList += makeDnsRuleObj().apply { server = "dns-direct" }
}
0L -> {
if (useFakeDns) userDNSRuleList += makeDnsRuleObj().apply {
server = "dns-fake"
inbound = listOf("tun-in")
}
userDNSRuleList += makeDnsRuleObj().apply {
server = "dns-remote"
}
}
-2L -> {
userDNSRuleList += makeDnsRuleObj().apply {
server = "dns-block"
disable_cache = true
}
}
}
outbound = when (val outId = rule.outbound) {
0L -> TAG_PROXY
-1L -> TAG_BYPASS
-2L -> TAG_BLOCK
else -> if (outId == proxy.id) TAG_PROXY else tagMap[outId] ?: ""
}
}
if (!ruleObj.checkEmpty()) {
if (ruleObj.outbound.isNullOrBlank()) {
Toast.makeText(
SagerNet.application,
"Warning: " + rule.displayName() + ": A non-existent outbound was specified.",
Toast.LENGTH_LONG
).show()
} else {
route.rules.add(ruleObj)
}
}
}
for (ruleSet in extraRules) {
if (ruleSet.domains.isNotBlank()) {
for (domain in ruleSet.domains.listByLineOrComma()) {
val s = makeSingBoxRuleSet(
domain,
"$externalAssets/geo"
)
if (!s.checkEmpty()) route.rule_set.add(s)
}
}
if (ruleSet.ip.isNotBlank()) {
for (iip in ruleSet.ip.listByLineOrComma()) {
val s = makeSingBoxRuleSet(
iip,
"$externalAssets/geo"
)
if (!s.checkEmpty()) route.rule_set.add(s)
}
}
}
route.rule_set = route.rule_set.distinctByTag()
for (freedom in arrayOf(TAG_DIRECT, TAG_BYPASS)) outbounds.add(Outbound().apply {
tag = freedom
type = "direct"
}.asMap())
outbounds.add(Outbound().apply {
tag = TAG_BLOCK
type = "block"
}.asMap())
if (!forTest) {
inbounds.add(0, Inbound_DirectOptions().apply {
type = "direct"
tag = TAG_DNS_IN
listen = bind
listen_port = DataStore.localDNSPort
override_address = "8.8.8.8"
override_port = 53
})
outbounds.add(Outbound().apply {
type = "dns"
tag = TAG_DNS_OUT
}.asMap())
}
// Bypass Lookup for the first profile
bypassDNSBeans.forEach {
var serverAddr = it.serverAddress
if (it is ConfigBean) {
var config = mutableMapOf<String, Any>()
config = gson.fromJson(it.config, config.javaClass)
config["server"]?.apply {
serverAddr = toString()
}
}
if (!serverAddr.isIpAddress()) {
domainListDNSDirectForce.add("full:${serverAddr}")
}
}
remoteDns.forEach {
var address = it
if (address.contains("://")) {
address = address.substringAfter("://")
}
"https://$address".toHttpUrlOrNull()?.apply {
if (!host.isIpAddress()) {
domainListDNSDirectForce.add("full:$host")
}
}
}
// remote dns obj
remoteDns.firstOrNull().let {
dns.servers.add(DNSServerOptions().apply {
address = it ?: throw Exception("No remote DNS, check your settings!")
tag = "dns-remote"
address_resolver = "dns-direct"
strategy = autoDnsDomainStrategy(SingBoxOptionsUtil.domainStrategy(tag))
})
}
// add directDNS objects here
directDNS.firstOrNull().let {
dns.servers.add(DNSServerOptions().apply {
address = it ?: throw Exception("No direct DNS, check your settings!")
tag = "dns-direct"
detour = TAG_DIRECT
address_resolver = "dns-local"
strategy = autoDnsDomainStrategy(SingBoxOptionsUtil.domainStrategy(tag))
})
}
// underlyingDns
underlyingDns.firstOrNull().let {
dns.servers.add(DNSServerOptions().apply {
address = it ?: "local"
tag = "dns-local"
detour = TAG_DIRECT
})
}
dns.servers.add(DNSServerOptions().apply {
address = "rcode://success"
tag = "dns-block"
})
// dns object user rules
if (enableDnsRouting) {
userDNSRuleList.forEach {
if (!it.checkEmpty()) dns.rules.add(it)
}
}
if (forTest) {
// Always use system DNS for urlTest
dns.servers = listOf(
DNSServerOptions().apply {
address = LOCAL_DNS_SERVER
tag = "dns-local"
detour = TAG_DIRECT
}
)
dns.rules = listOf()
} else {
// built-in DNS rules
route.rules.add(0, Rule_DefaultOptions().apply {
inbound = listOf(TAG_DNS_IN)
outbound = TAG_DNS_OUT
})
route.rules.add(0, Rule_DefaultOptions().apply {
port = listOf(53)
outbound = TAG_DNS_OUT
}) // TODO new mode use system dns?
if (DataStore.bypassLanInCore) {
route.rules.add(Rule_DefaultOptions().apply {
outbound = TAG_BYPASS
ip_is_private = true
})
}
// block mcast
route.rules.add(Rule_DefaultOptions().apply {
ip_cidr = listOf("224.0.0.0/3", "ff00::/8")
source_ip_cidr = listOf("224.0.0.0/3", "ff00::/8")
outbound = TAG_BLOCK
})
// FakeDNS obj
if (useFakeDns) {
dns.fakeip = DNSFakeIPOptions().apply {
enabled = true
inet4_range = "198.18.0.0/15"
inet6_range = "fc00::/18"
}
dns.servers.add(DNSServerOptions().apply {
address = "fakeip"
tag = "dns-fake"
strategy = "ipv4_only" // TODO: remove
})
dns.rules.add(DNSRule_DefaultOptions().apply {
inbound = listOf("tun-in")
server = "dns-fake"
disable_cache = true
})
}
// force bypass (always top DNS rule)
if (domainListDNSDirectForce.isNotEmpty()) {
dns.rules.add(0, DNSRule_DefaultOptions().apply {
makeSingBoxRule(domainListDNSDirectForce.toHashSet().toList())
server = "dns-direct"
})
}
}
}.let {
ConfigBuildResult(
gson.toJson(it.asMap().apply {
Util.mergeJSON(optionsToMerge, this)
}),
externalIndexMap,
proxy.id,
trafficMap,
tagMap,
if (buildSelector) group!!.id else -1L
)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/ConfigBuilder.kt | 1101248347 |
package io.nekohasekai.sagernet.fmt.hysteria
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.fmt.LOCALHOST
import io.nekohasekai.sagernet.ktx.*
import moe.matsuri.nb4a.SingBoxOptions
import moe.matsuri.nb4a.SingBoxOptions.OutboundECHOptions
import moe.matsuri.nb4a.utils.listByLineOrComma
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import org.json.JSONObject
import java.io.File
// hysteria://host:port?auth=123456&peer=sni.domain&insecure=1|0&upmbps=100&downmbps=100&alpn=hysteria&obfs=xplus&obfsParam=123456#remarks
fun parseHysteria1(url: String): HysteriaBean {
val link = url.replace("hysteria://", "https://").toHttpUrlOrNull() ?: error(
"invalid hysteria link $url"
)
return HysteriaBean().apply {
protocolVersion = 1
serverAddress = link.host
serverPorts = link.port.toString()
name = link.fragment
link.queryParameter("mport")?.also {
serverPorts = it
}
link.queryParameter("peer")?.also {
sni = it
}
link.queryParameter("auth")?.takeIf { it.isNotBlank() }?.also {
authPayloadType = HysteriaBean.TYPE_STRING
authPayload = it
}
link.queryParameter("insecure")?.also {
allowInsecure = it == "1" || it == "true"
}
link.queryParameter("upmbps")?.also {
uploadMbps = it.toIntOrNull() ?: uploadMbps
}
link.queryParameter("downmbps")?.also {
downloadMbps = it.toIntOrNull() ?: downloadMbps
}
link.queryParameter("alpn")?.also {
alpn = it
}
link.queryParameter("obfsParam")?.also {
obfuscation = it
}
link.queryParameter("protocol")?.also {
when (it) {
"faketcp" -> {
protocol = HysteriaBean.PROTOCOL_FAKETCP
}
"wechat-video" -> {
protocol = HysteriaBean.PROTOCOL_WECHAT_VIDEO
}
}
}
}
}
// hysteria2://[auth@]hostname[:port]/?[key=value]&[key=value]...
fun parseHysteria2(url: String): HysteriaBean {
val link = url
.replace("hysteria2://", "https://")
.replace("hy2://", "https://")
.toHttpUrlOrNull() ?: error("invalid hysteria link $url")
return HysteriaBean().apply {
protocolVersion = 2
serverAddress = link.host
serverPorts = link.port.toString()
authPayload = if (link.password.isNotBlank()) {
link.username + ":" + link.password
} else {
link.username
}
name = link.fragment
link.queryParameter("mport")?.also {
serverPorts = it
}
link.queryParameter("sni")?.also {
sni = it
}
link.queryParameter("insecure")?.also {
allowInsecure = it == "1" || it == "true"
}
// link.queryParameter("upmbps")?.also {
// uploadMbps = it.toIntOrNull() ?: uploadMbps
// }
// link.queryParameter("downmbps")?.also {
// downloadMbps = it.toIntOrNull() ?: downloadMbps
// }
link.queryParameter("obfs-password")?.also {
obfuscation = it
}
link.queryParameter("pinSHA256")?.also {
// TODO your box do not support it
}
}
}
fun HysteriaBean.toUri(): String {
var un = ""
var pw = ""
if (protocolVersion == 2) {
if (authPayload.contains(":")) {
un = authPayload.substringBefore(":")
pw = authPayload.substringAfter(":")
} else {
un = authPayload
}
}
//
val builder = linkBuilder()
.host(serverAddress.wrapIPV6Host())
.port(getFirstPort(serverPorts))
.username(un)
.password(pw)
if (isMultiPort(displayAddress())) {
builder.addQueryParameter("mport", serverPorts)
}
if (name.isNotBlank()) {
builder.encodedFragment(name.urlSafe())
}
if (allowInsecure) {
builder.addQueryParameter("insecure", "1")
}
if (protocolVersion == 1) {
if (sni.isNotBlank()) {
builder.addQueryParameter("peer", sni)
}
if (authPayload.isNotBlank()) {
builder.addQueryParameter("auth", authPayload)
}
builder.addQueryParameter("upmbps", "$uploadMbps")
builder.addQueryParameter("downmbps", "$downloadMbps")
if (alpn.isNotBlank()) {
builder.addQueryParameter("alpn", alpn)
}
if (obfuscation.isNotBlank()) {
builder.addQueryParameter("obfs", "xplus")
builder.addQueryParameter("obfsParam", obfuscation)
}
when (protocol) {
HysteriaBean.PROTOCOL_FAKETCP -> {
builder.addQueryParameter("protocol", "faketcp")
}
HysteriaBean.PROTOCOL_WECHAT_VIDEO -> {
builder.addQueryParameter("protocol", "wechat-video")
}
}
} else {
if (sni.isNotBlank()) {
builder.addQueryParameter("sni", sni)
}
if (obfuscation.isNotBlank()) {
builder.addQueryParameter("obfs", "salamander")
builder.addQueryParameter("obfs-password", obfuscation)
}
}
return builder.toLink(if (protocolVersion == 2) "hy2" else "hysteria")
}
fun JSONObject.parseHysteria1Json(): HysteriaBean {
// TODO parse HY2 JSON+YAML
return HysteriaBean().apply {
protocolVersion = 1
serverAddress = optString("server").substringBeforeLast(":")
serverPorts = optString("server").substringAfterLast(":")
uploadMbps = getIntNya("up_mbps")
downloadMbps = getIntNya("down_mbps")
obfuscation = getStr("obfs")
getStr("auth")?.also {
authPayloadType = HysteriaBean.TYPE_BASE64
authPayload = it
}
getStr("auth_str")?.also {
authPayloadType = HysteriaBean.TYPE_STRING
authPayload = it
}
getStr("protocol")?.also {
when (it) {
"faketcp" -> {
protocol = HysteriaBean.PROTOCOL_FAKETCP
}
"wechat-video" -> {
protocol = HysteriaBean.PROTOCOL_WECHAT_VIDEO
}
}
}
sni = getStr("server_name")
alpn = getStr("alpn")
allowInsecure = getBool("insecure")
streamReceiveWindow = getIntNya("recv_window_conn")
connectionReceiveWindow = getIntNya("recv_window")
disableMtuDiscovery = getBool("disable_mtu_discovery")
}
}
fun HysteriaBean.buildHysteria1Config(port: Int, cacheFile: (() -> File)?): String {
if (protocolVersion != 1) {
throw Exception("error version: $protocolVersion")
}
return JSONObject().apply {
put("server", displayAddress())
when (protocol) {
HysteriaBean.PROTOCOL_FAKETCP -> {
put("protocol", "faketcp")
}
HysteriaBean.PROTOCOL_WECHAT_VIDEO -> {
put("protocol", "wechat-video")
}
}
put("up_mbps", uploadMbps)
put("down_mbps", downloadMbps)
put(
"socks5", JSONObject(
mapOf(
"listen" to "$LOCALHOST:$port",
)
)
)
put("retry", 5)
put("fast_open", true)
put("lazy_start", true)
put("obfs", obfuscation)
when (authPayloadType) {
HysteriaBean.TYPE_BASE64 -> put("auth", authPayload)
HysteriaBean.TYPE_STRING -> put("auth_str", authPayload)
}
if (sni.isBlank() && finalAddress == LOCALHOST && !serverAddress.isIpAddress()) {
sni = serverAddress
}
if (sni.isNotBlank()) {
put("server_name", sni)
}
if (alpn.isNotBlank()) put("alpn", alpn)
if (caText.isNotBlank() && cacheFile != null) {
val caFile = cacheFile()
caFile.writeText(caText)
put("ca", caFile.absolutePath)
}
if (allowInsecure) put("insecure", true)
if (streamReceiveWindow > 0) put("recv_window_conn", streamReceiveWindow)
if (connectionReceiveWindow > 0) put("recv_window", connectionReceiveWindow)
if (disableMtuDiscovery) put("disable_mtu_discovery", true)
// hy 1.2.0 （不兼容）
put("resolver", "udp://127.0.0.1:" + DataStore.localDNSPort)
put("hop_interval", hopInterval)
}.toStringPretty()
}
fun isMultiPort(hyAddr: String): Boolean {
if (!hyAddr.contains(":")) return false
val p = hyAddr.substringAfterLast(":")
if (p.contains("-") || p.contains(",")) return true
return false
}
fun getFirstPort(portStr: String): Int {
return portStr.substringBefore(":").substringBefore(",").toIntOrNull() ?: 443
}
fun HysteriaBean.canUseSingBox(): Boolean {
if (protocol != HysteriaBean.PROTOCOL_UDP) return false
return true
}
fun buildSingBoxOutboundHysteriaBean(bean: HysteriaBean): MutableMap<String, Any> {
return when (bean.protocolVersion) {
1 -> SingBoxOptions.Outbound_HysteriaOptions().apply {
type = "hysteria"
server = bean.serverAddress
val port = bean.serverPorts.toIntOrNull()
if (port != null) {
server_port = port
} else {
hop_ports = bean.serverPorts
}
hop_interval = bean.hopInterval
up_mbps = bean.uploadMbps
down_mbps = bean.downloadMbps
obfs = bean.obfuscation
disable_mtu_discovery = bean.disableMtuDiscovery
when (bean.authPayloadType) {
HysteriaBean.TYPE_BASE64 -> auth = bean.authPayload
HysteriaBean.TYPE_STRING -> auth_str = bean.authPayload
}
if (bean.streamReceiveWindow > 0) {
recv_window_conn = bean.streamReceiveWindow.toLong()
}
if (bean.connectionReceiveWindow > 0) {
recv_window_conn = bean.connectionReceiveWindow.toLong()
}
tls = SingBoxOptions.OutboundTLSOptions().apply {
if (bean.sni.isNotBlank()) {
server_name = bean.sni
}
if (bean.alpn.isNotBlank()) {
alpn = bean.alpn.listByLineOrComma()
}
if (bean.caText.isNotBlank()) {
certificate = bean.caText
}
if (bean.ech) {
val echList = bean.echCfg.split("\n")
ech = OutboundECHOptions().apply {
enabled = true
pq_signature_schemes_enabled = echList.size > 5
dynamic_record_sizing_disabled = true
config = echList
}
}
insecure = bean.allowInsecure || DataStore.globalAllowInsecure
enabled = true
}
}.asMap()
2 -> SingBoxOptions.Outbound_Hysteria2Options().apply {
type = "hysteria2"
server = bean.serverAddress
val port = bean.serverPorts.toIntOrNull()
if (port != null) {
server_port = port
} else {
hop_ports = bean.serverPorts
}
hop_interval = bean.hopInterval
up_mbps = bean.uploadMbps
down_mbps = bean.downloadMbps
if (bean.obfuscation.isNotBlank()) {
obfs = SingBoxOptions.Hysteria2Obfs().apply {
type = "salamander"
password = bean.obfuscation
}
}
// disable_mtu_discovery = bean.disableMtuDiscovery
password = bean.authPayload
// if (bean.streamReceiveWindow > 0) {
// recv_window_conn = bean.streamReceiveWindow.toLong()
// }
// if (bean.connectionReceiveWindow > 0) {
// recv_window_conn = bean.connectionReceiveWindow.toLong()
// }
tls = SingBoxOptions.OutboundTLSOptions().apply {
if (bean.sni.isNotBlank()) {
server_name = bean.sni
}
alpn = listOf("h3")
if (bean.caText.isNotBlank()) {
certificate = bean.caText
}
if (bean.ech) {
val echList = bean.echCfg.split("\n")
ech = OutboundECHOptions().apply {
enabled = true
pq_signature_schemes_enabled = echList.size > 5
dynamic_record_sizing_disabled = true
config = echList
}
}
insecure = bean.allowInsecure || DataStore.globalAllowInsecure
enabled = true
}
}.asMap()
else -> mutableMapOf("error_version" to bean.protocolVersion)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/hysteria/HysteriaFmt.kt | 848503070 |
package io.nekohasekai.sagernet.fmt.naive
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.fmt.LOCALHOST
import io.nekohasekai.sagernet.ktx.*
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import org.json.JSONObject
fun parseNaive(link: String): NaiveBean {
val proto = link.substringAfter("+").substringBefore(":")
val url = ("https://" + link.substringAfter("://")).toHttpUrlOrNull()
?: error("Invalid naive link: $link")
return NaiveBean().also {
it.proto = proto
}.apply {
serverAddress = url.host
serverPort = url.port
username = url.username
password = url.password
sni = url.queryParameter("sni")
extraHeaders = url.queryParameter("extra-headers")?.unUrlSafe()?.replace("\r\n", "\n")
insecureConcurrency = url.queryParameter("insecure-concurrency")?.toIntOrNull()
name = url.fragment
initializeDefaultValues()
}
}
fun NaiveBean.toUri(proxyOnly: Boolean = false): String {
val builder = linkBuilder().host(finalAddress).port(finalPort)
if (username.isNotBlank()) {
builder.username(username)
}
if (password.isNotBlank()) {
builder.password(password)
}
if (!proxyOnly) {
if (sni.isNotBlank()) {
builder.addQueryParameter("sni", sni)
}
if (extraHeaders.isNotBlank()) {
builder.addQueryParameter("extra-headers", extraHeaders)
}
if (name.isNotBlank()) {
builder.encodedFragment(name.urlSafe())
}
if (insecureConcurrency > 0) {
builder.addQueryParameter("insecure-concurrency", "$insecureConcurrency")
}
}
return builder.toLink(if (proxyOnly) proto else "naive+$proto", false)
}
fun NaiveBean.buildNaiveConfig(port: Int): String {
return JSONObject().apply {
// process ipv6
finalAddress = finalAddress.wrapIPV6Host()
serverAddress = serverAddress.wrapIPV6Host()
// process sni
if (sni.isNotBlank()) {
put("host-resolver-rules", "MAP $sni $finalAddress")
finalAddress = sni
} else {
if (serverAddress.isIpAddress()) {
// for naive, using IP as SNI name hardly happens
// and host-resolver-rules cannot resolve the SNI problem
// so do nothing
} else {
put("host-resolver-rules", "MAP $serverAddress $finalAddress")
finalAddress = serverAddress
}
}
put("listen", "socks://$LOCALHOST:$port")
put("proxy", toUri(true))
if (extraHeaders.isNotBlank()) {
put("extra-headers", extraHeaders.split("\n").joinToString("\r\n"))
}
if (DataStore.logLevel > 0) {
put("log", "")
}
if (insecureConcurrency > 0) {
put("insecure-concurrency", insecureConcurrency)
}
}.toStringPretty()
} | nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/naive/NaiveFmt.kt | 1248696359 |
package io.nekohasekai.sagernet.fmt
import io.nekohasekai.sagernet.database.ProxyEntity
import io.nekohasekai.sagernet.database.ProxyGroup
import moe.matsuri.nb4a.utils.Util
fun parseUniversal(link: String): AbstractBean {
return if (link.contains("?")) {
val type = link.substringAfter("sn://").substringBefore("?")
ProxyEntity(type = TypeMap[type] ?: error("Type $type not found")).apply {
putByteArray(Util.zlibDecompress(Util.b64Decode(link.substringAfter("?"))))
}.requireBean()
} else {
val type = link.substringAfter("sn://").substringBefore(":")
ProxyEntity(type = TypeMap[type] ?: error("Type $type not found")).apply {
putByteArray(Util.b64Decode(link.substringAfter(":").substringAfter(":")))
}.requireBean()
}
}
fun AbstractBean.toUniversalLink(): String {
var link = "sn://"
link += TypeMap.reversed[ProxyEntity().putBean(this).type]
link += "?"
link += Util.b64EncodeUrlSafe(Util.zlibCompress(KryoConverters.serialize(this), 9))
return link
}
fun ProxyGroup.toUniversalLink(): String {
var link = "sn://subscription?"
export = true
link += Util.b64EncodeUrlSafe(Util.zlibCompress(KryoConverters.serialize(this), 9))
export = false
return link
} | nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/UniversalFmt.kt | 2516682805 |
/******************************************************************************
* Copyright (C) 2022 by nekohasekai <[email protected]> *
* *
* This program 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 program 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. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* *
******************************************************************************/
package io.nekohasekai.sagernet.fmt.mieru
import io.nekohasekai.sagernet.ktx.toStringPretty
import org.json.JSONArray
import org.json.JSONObject
fun MieruBean.buildMieruConfig(port: Int): String {
return JSONObject().apply {
put("activeProfile", "default")
put("socks5Port", port)
// TODO: follow NekoBox logging level.
put("loggingLevel", "INFO")
put("profiles", JSONArray().apply {
put(JSONObject().apply {
put("profileName", "default")
put("user", JSONObject().apply {
put("name", username)
put("password", password)
})
put("servers", JSONArray().apply {
put(JSONObject().apply {
put("ipAddress", finalAddress)
put("portBindings", JSONArray().apply {
put(JSONObject().apply {
put("port", finalPort)
put("protocol", protocol)
})
})
})
})
})
})
}.toStringPretty()
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/mieru/MieruFmt.kt | 3665834992 |
package io.nekohasekai.sagernet.fmt.ssh
import moe.matsuri.nb4a.SingBoxOptions
import moe.matsuri.nb4a.utils.listByLineOrComma
fun buildSingBoxOutboundSSHBean(bean: SSHBean): SingBoxOptions.Outbound_SSHOptions {
return SingBoxOptions.Outbound_SSHOptions().apply {
type = "ssh"
server = bean.serverAddress
server_port = bean.serverPort
user = bean.username
if (bean.publicKey.isNotBlank()) {
host_key = bean.publicKey.listByLineOrComma()
}
when (bean.authType) {
SSHBean.AUTH_TYPE_PRIVATE_KEY -> {
private_key = bean.privateKey
private_key_passphrase = bean.privateKeyPassphrase
}
else -> {
password = bean.password
}
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/ssh/SSHFmt.kt | 3533818787 |
package io.nekohasekai.sagernet.fmt.http
import io.nekohasekai.sagernet.fmt.v2ray.isTLS
import io.nekohasekai.sagernet.fmt.v2ray.setTLS
import io.nekohasekai.sagernet.ktx.urlSafe
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
fun parseHttp(link: String): HttpBean {
val httpUrl = link.toHttpUrlOrNull() ?: error("Invalid http(s) link: $link")
if (httpUrl.encodedPath != "/") error("Not http proxy")
return HttpBean().apply {
serverAddress = httpUrl.host
serverPort = httpUrl.port
username = httpUrl.username
password = httpUrl.password
sni = httpUrl.queryParameter("sni")
name = httpUrl.fragment
setTLS(httpUrl.scheme == "https")
}
}
fun HttpBean.toUri(): String {
val builder = HttpUrl.Builder().scheme(if (isTLS()) "https" else "http").host(serverAddress)
if (serverPort in 1..65535) {
builder.port(serverPort)
}
if (username.isNotBlank()) {
builder.username(username)
}
if (password.isNotBlank()) {
builder.password(password)
}
if (sni.isNotBlank()) {
builder.addQueryParameter("sni", sni)
}
if (name.isNotBlank()) {
builder.encodedFragment(name.urlSafe())
}
return builder.toString()
} | nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/http/HttpFmt.kt | 4060565171 |
package io.nekohasekai.sagernet.fmt.socks
import io.nekohasekai.sagernet.ktx.decodeBase64UrlSafe
import io.nekohasekai.sagernet.ktx.toLink
import io.nekohasekai.sagernet.ktx.urlSafe
import moe.matsuri.nb4a.SingBoxOptions
import moe.matsuri.nb4a.utils.NGUtil
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
fun parseSOCKS(link: String): SOCKSBean {
val url = ("http://" + link.substringAfter("://")).toHttpUrlOrNull()
?: error("Not supported: $link")
return SOCKSBean().apply {
protocol = when {
link.startsWith("socks4://") -> SOCKSBean.PROTOCOL_SOCKS4
link.startsWith("socks4a://") -> SOCKSBean.PROTOCOL_SOCKS4A
else -> SOCKSBean.PROTOCOL_SOCKS5
}
name = url.fragment
serverAddress = url.host
serverPort = url.port
username = url.username
password = url.password
// v2rayN fmt
if (password.isNullOrBlank() && !username.isNullOrBlank()) {
try {
val n = username.decodeBase64UrlSafe()
username = n.substringBefore(":")
password = n.substringAfter(":")
} catch (_: Exception) {
}
}
}
}
fun SOCKSBean.toUri(): String {
val builder = HttpUrl.Builder().scheme("http").host(serverAddress).port(serverPort)
if (!username.isNullOrBlank()) builder.username(username)
if (!password.isNullOrBlank()) builder.password(password)
if (!name.isNullOrBlank()) builder.encodedFragment(name.urlSafe())
return builder.toLink("socks${protocolVersion()}")
}
fun SOCKSBean.toV2rayN(): String {
var link = ""
if (username.isNotBlank()) {
link += username.urlSafe() + ":" + password.urlSafe() + "@"
}
link += "$serverAddress:$serverPort"
link = "socks://" + NGUtil.encode(link)
if (name.isNotBlank()) {
link += "#" + name.urlSafe()
}
return link
}
fun buildSingBoxOutboundSocksBean(bean: SOCKSBean): SingBoxOptions.Outbound_SocksOptions {
return SingBoxOptions.Outbound_SocksOptions().apply {
type = "socks"
server = bean.serverAddress
server_port = bean.serverPort
username = bean.username
password = bean.password
version = bean.protocolVersionName()
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/socks/SOCKSFmt.kt | 1226603263 |
package io.nekohasekai.sagernet.fmt
import android.os.Parcel
import android.os.Parcelable
import com.esotericsoftware.kryo.io.ByteBufferInput
import com.esotericsoftware.kryo.io.ByteBufferOutput
abstract class Serializable : Parcelable {
abstract fun initializeDefaultValues()
abstract fun serializeToBuffer(output: ByteBufferOutput)
abstract fun deserializeFromBuffer(input: ByteBufferInput)
override fun describeContents() = 0
override fun writeToParcel(dest: Parcel, flags: Int) {
dest.writeByteArray(KryoConverters.serialize(this))
}
abstract class CREATOR<T : Serializable> : Parcelable.Creator<T> {
abstract fun newInstance(): T
override fun createFromParcel(source: Parcel): T {
return KryoConverters.deserialize(newInstance(), source.createByteArray())
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/Serializable.kt | 2278594813 |
package io.nekohasekai.sagernet.fmt.tuic
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.ktx.linkBuilder
import io.nekohasekai.sagernet.ktx.toLink
import io.nekohasekai.sagernet.ktx.urlSafe
import moe.matsuri.nb4a.SingBoxOptions
import moe.matsuri.nb4a.SingBoxOptions.OutboundECHOptions
import moe.matsuri.nb4a.utils.listByLineOrComma
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
fun parseTuic(url: String): TuicBean {
// https://github.com/daeuniverse/dae/discussions/182
val link = url.replace("tuic://", "https://").toHttpUrlOrNull() ?: error(
"invalid tuic link $url"
)
return TuicBean().apply {
protocolVersion = 5
name = link.fragment
uuid = link.username
token = link.password
serverAddress = link.host
serverPort = link.port
link.queryParameter("sni")?.let {
sni = it
}
link.queryParameter("congestion_control")?.let {
congestionController = it
}
link.queryParameter("udp_relay_mode")?.let {
udpRelayMode = it
}
link.queryParameter("alpn")?.let {
alpn = it
}
link.queryParameter("allow_insecure")?.let {
if (it == "1") allowInsecure = true
}
link.queryParameter("disable_sni")?.let {
if (it == "1") disableSNI = true
}
}
}
fun TuicBean.toUri(): String {
val builder = linkBuilder().username(uuid).password(token).host(serverAddress).port(serverPort)
builder.addQueryParameter("congestion_control", congestionController)
var udpMode = udpRelayMode
if (udpMode == "UDP over Stream") udpMode = "native"
builder.addQueryParameter("udp_relay_mode", udpMode)
if (sni.isNotBlank()) builder.addQueryParameter("sni", sni)
if (alpn.isNotBlank()) builder.addQueryParameter("alpn", alpn)
if (allowInsecure) builder.addQueryParameter("allow_insecure", "1")
if (disableSNI) builder.addQueryParameter("disable_sni", "1")
if (name.isNotBlank()) builder.encodedFragment(name.urlSafe())
return builder.toLink("tuic")
}
fun buildSingBoxOutboundTuicBean(bean: TuicBean): SingBoxOptions.Outbound_TUICOptions {
if (bean.protocolVersion == 4) throw Exception("TUIC v4 is no longer supported")
return SingBoxOptions.Outbound_TUICOptions().apply {
type = "tuic"
server = bean.serverAddress
server_port = bean.serverPort
uuid = bean.uuid
password = bean.token
congestion_control = bean.congestionController
if (bean.udpRelayMode == "UDP over Stream") {
udp_over_stream = true
} else {
udp_relay_mode = bean.udpRelayMode
udp_over_stream = false
}
zero_rtt_handshake = bean.reduceRTT
tls = SingBoxOptions.OutboundTLSOptions().apply {
if (bean.sni.isNotBlank()) {
server_name = bean.sni
}
if (bean.alpn.isNotBlank()) {
alpn = bean.alpn.listByLineOrComma()
}
if (bean.caText.isNotBlank()) {
certificate = bean.caText
}
if (bean.ech) {
val echList = bean.echCfg.split("\n")
ech = OutboundECHOptions().apply {
enabled = true
pq_signature_schemes_enabled = echList.size > 5
dynamic_record_sizing_disabled = true
config = echList
}
}
disable_sni = bean.disableSNI
insecure = bean.allowInsecure || DataStore.globalAllowInsecure
enabled = true
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/tuic/TuicFmt.kt | 1345185870 |
package io.nekohasekai.sagernet.fmt.wireguard
import moe.matsuri.nb4a.SingBoxOptions
import moe.matsuri.nb4a.utils.Util
import moe.matsuri.nb4a.utils.listByLineOrComma
fun genReserved(anyStr: String): String {
try {
val list = anyStr.listByLineOrComma()
val ba = ByteArray(3)
if (list.size == 3) {
list.forEachIndexed { index, s ->
val i = s
.replace("[", "")
.replace("]", "")
.replace(" ", "")
.toIntOrNull() ?: return anyStr
ba[index] = i.toByte()
}
return Util.b64EncodeOneLine(ba)
} else {
return anyStr
}
} catch (e: Exception) {
return anyStr
}
}
fun buildSingBoxOutboundWireguardBean(bean: WireGuardBean): SingBoxOptions.Outbound_WireGuardOptions {
return SingBoxOptions.Outbound_WireGuardOptions().apply {
type = "wireguard"
server = bean.serverAddress
server_port = bean.serverPort
local_address = bean.localAddress.listByLineOrComma()
private_key = bean.privateKey
peer_public_key = bean.peerPublicKey
pre_shared_key = bean.peerPreSharedKey
mtu = bean.mtu
if (bean.reserved.isNotBlank()) reserved = genReserved(bean.reserved)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/wireguard/WireGuardFmt.kt | 165382848 |
package io.nekohasekai.sagernet.fmt.shadowsocks
import io.nekohasekai.sagernet.ktx.*
import moe.matsuri.nb4a.SingBoxOptions
import moe.matsuri.nb4a.utils.Util
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import org.json.JSONObject
fun ShadowsocksBean.fixPluginName() {
if (plugin.startsWith("simple-obfs")) {
plugin = plugin.replaceFirst("simple-obfs", "obfs-local")
}
}
fun parseShadowsocks(url: String): ShadowsocksBean {
if (url.substringBefore("#").contains("@")) {
var link = url.replace("ss://", "https://").toHttpUrlOrNull() ?: error(
"invalid ss-android link $url"
)
if (link.username.isBlank()) { // fix justmysocks's shit link
link = (("https://" + url.substringAfter("ss://")
.substringBefore("#")
.decodeBase64UrlSafe()).toHttpUrlOrNull()
?: error("invalid jms link $url")
).newBuilder().fragment(url.substringAfter("#")).build()
}
// ss-android style
if (link.password.isNotBlank()) {
return ShadowsocksBean().apply {
serverAddress = link.host
serverPort = link.port
method = link.username
password = link.password
plugin = link.queryParameter("plugin") ?: ""
name = link.fragment
fixPluginName()
}
}
val methodAndPswd = link.username.decodeBase64UrlSafe()
return ShadowsocksBean().apply {
serverAddress = link.host
serverPort = link.port
method = methodAndPswd.substringBefore(":")
password = methodAndPswd.substringAfter(":")
plugin = link.queryParameter("plugin") ?: ""
name = link.fragment
fixPluginName()
}
} else {
// v2rayN style
var v2Url = url
if (v2Url.contains("#")) v2Url = v2Url.substringBefore("#")
val link = ("https://" + v2Url.substringAfter("ss://")
.decodeBase64UrlSafe()).toHttpUrlOrNull() ?: error("invalid v2rayN link $url")
return ShadowsocksBean().apply {
serverAddress = link.host
serverPort = link.port
method = link.username
password = link.password
plugin = ""
val remarks = url.substringAfter("#").unUrlSafe()
if (remarks.isNotBlank()) name = remarks
}
}
}
fun ShadowsocksBean.toUri(): String {
val builder = linkBuilder().username(Util.b64EncodeUrlSafe("$method:$password"))
.host(serverAddress)
.port(serverPort)
if (plugin.isNotBlank()) {
builder.addQueryParameter("plugin", plugin)
}
if (name.isNotBlank()) {
builder.encodedFragment(name.urlSafe())
}
return builder.toLink("ss").replace("$serverPort/", "$serverPort")
}
fun JSONObject.parseShadowsocks(): ShadowsocksBean {
return ShadowsocksBean().apply {
serverAddress = getStr("server")
serverPort = getIntNya("server_port")
password = getStr("password")
method = getStr("method")
name = optString("remarks", "")
val pId = getStr("plugin")
if (!pId.isNullOrBlank()) {
plugin = pId + ";" + optString("plugin_opts", "")
}
}
}
fun buildSingBoxOutboundShadowsocksBean(bean: ShadowsocksBean): SingBoxOptions.Outbound_ShadowsocksOptions {
return SingBoxOptions.Outbound_ShadowsocksOptions().apply {
type = "shadowsocks"
server = bean.serverAddress
server_port = bean.serverPort
password = bean.password
method = bean.method
if (bean.plugin.isNotBlank()) {
plugin = bean.plugin.substringBefore(";")
plugin_opts = bean.plugin.substringAfter(";")
}
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/fmt/shadowsocks/ShadowsocksFmt.kt | 1751700427 |
package io.nekohasekai.sagernet.ktx
import com.google.gson.JsonParser
import io.nekohasekai.sagernet.fmt.AbstractBean
import io.nekohasekai.sagernet.fmt.Serializable
import io.nekohasekai.sagernet.fmt.http.parseHttp
import io.nekohasekai.sagernet.fmt.hysteria.parseHysteria1
import io.nekohasekai.sagernet.fmt.hysteria.parseHysteria2
import io.nekohasekai.sagernet.fmt.naive.parseNaive
import io.nekohasekai.sagernet.fmt.parseUniversal
import io.nekohasekai.sagernet.fmt.shadowsocks.parseShadowsocks
import io.nekohasekai.sagernet.fmt.socks.parseSOCKS
import io.nekohasekai.sagernet.fmt.trojan.parseTrojan
import io.nekohasekai.sagernet.fmt.trojan_go.parseTrojanGo
import io.nekohasekai.sagernet.fmt.tuic.parseTuic
import io.nekohasekai.sagernet.fmt.v2ray.parseV2Ray
import moe.matsuri.nb4a.plugin.NekoPluginManager
import moe.matsuri.nb4a.proxy.neko.NekoJSInterface
import moe.matsuri.nb4a.proxy.neko.parseShareLink
import moe.matsuri.nb4a.utils.JavaUtil.gson
import moe.matsuri.nb4a.utils.Util
import org.json.JSONArray
import org.json.JSONException
import org.json.JSONObject
// JSON & Base64
fun JSONObject.toStringPretty(): String {
return gson.toJson(JsonParser.parseString(this.toString()))
}
inline fun <reified T : Any> JSONArray.filterIsInstance(): List<T> {
val list = mutableListOf<T>()
for (i in 0 until this.length()) {
if (this[i] is T) list.add(this[i] as T)
}
return list
}
inline fun JSONArray.forEach(action: (Int, Any) -> Unit) {
for (i in 0 until this.length()) {
action(i, this[i])
}
}
inline fun JSONObject.forEach(action: (String, Any) -> Unit) {
for (k in this.keys()) {
action(k, this.get(k))
}
}
fun isJsonObjectValid(j: Any): Boolean {
if (j is JSONObject) return true
if (j is JSONArray) return true
try {
JSONObject(j as String)
} catch (ex: JSONException) {
try {
JSONArray(j)
} catch (ex1: JSONException) {
return false
}
}
return true
}
// wtf hutool
fun JSONObject.getStr(name: String): String? {
val obj = this.opt(name) ?: return null
if (obj is String) {
if (obj.isBlank()) {
return null
}
return obj
} else {
return null
}
}
fun JSONObject.getBool(name: String): Boolean? {
return try {
getBoolean(name)
} catch (ignored: Exception) {
null
}
}
// 重名了喵
fun JSONObject.getIntNya(name: String): Int? {
return try {
getInt(name)
} catch (ignored: Exception) {
null
}
}
fun String.decodeBase64UrlSafe(): String {
return String(Util.b64Decode(this))
}
// Sub
class SubscriptionFoundException(val link: String) : RuntimeException()
suspend fun parseProxies(text: String): List<AbstractBean> {
val links = text.split('\n').flatMap { it.trim().split(' ') }
val linksByLine = text.split('\n').map { it.trim() }
val entities = ArrayList<AbstractBean>()
val entitiesByLine = ArrayList<AbstractBean>()
suspend fun String.parseLink(entities: ArrayList<AbstractBean>) {
if (startsWith("clash://install-config?") || startsWith("sn://subscription?")) {
throw SubscriptionFoundException(this)
}
if (startsWith("sn://")) {
Logs.d("Try parse universal link: $this")
runCatching {
entities.add(parseUniversal(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("socks://") || startsWith("socks4://") || startsWith("socks4a://") || startsWith(
"socks5://"
)
) {
Logs.d("Try parse socks link: $this")
runCatching {
entities.add(parseSOCKS(this))
}.onFailure {
Logs.w(it)
}
} else if (matches("(http|https)://.*".toRegex())) {
Logs.d("Try parse http link: $this")
runCatching {
entities.add(parseHttp(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("vmess://")) {
Logs.d("Try parse v2ray link: $this")
runCatching {
entities.add(parseV2Ray(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("vless://")) {
Logs.d("Try parse vless link: $this")
runCatching {
entities.add(parseV2Ray(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("trojan://")) {
Logs.d("Try parse trojan link: $this")
runCatching {
entities.add(parseTrojan(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("trojan-go://")) {
Logs.d("Try parse trojan-go link: $this")
runCatching {
entities.add(parseTrojanGo(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("ss://")) {
Logs.d("Try parse shadowsocks link: $this")
runCatching {
entities.add(parseShadowsocks(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("naive+")) {
Logs.d("Try parse naive link: $this")
runCatching {
entities.add(parseNaive(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("hysteria://")) {
Logs.d("Try parse hysteria1 link: $this")
runCatching {
entities.add(parseHysteria1(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("hysteria2://") || startsWith("hy2://")) {
Logs.d("Try parse hysteria2 link: $this")
runCatching {
entities.add(parseHysteria2(this))
}.onFailure {
Logs.w(it)
}
} else if (startsWith("tuic://")) {
Logs.d("Try parse TUIC link: $this")
runCatching {
entities.add(parseTuic(this))
}.onFailure {
Logs.w(it)
}
} else { // Neko Plugins
NekoPluginManager.getProtocols().forEach { obj ->
obj.protocolConfig.optJSONArray("links")?.forEach { _, any ->
if (any is String && startsWith(any)) {
runCatching {
entities.add(
parseShareLink(
obj.plgId, obj.protocolId, this@parseLink
)
)
}.onFailure {
Logs.w(it)
}
}
}
}
}
}
for (link in links) {
link.parseLink(entities)
}
for (link in linksByLine) {
link.parseLink(entitiesByLine)
}
var isBadLink = false
if (entities.onEach { it.initializeDefaultValues() }.size == entitiesByLine.onEach { it.initializeDefaultValues() }.size) run test@{
entities.forEachIndexed { index, bean ->
val lineBean = entitiesByLine[index]
if (bean == lineBean && bean.displayName() != lineBean.displayName()) {
isBadLink = true
return@test
}
}
}
NekoJSInterface.Default.destroyAllJsi()
return if (entities.size > entitiesByLine.size) entities else entitiesByLine
}
fun <T : Serializable> T.applyDefaultValues(): T {
initializeDefaultValues()
return this
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Formats.kt | 1484057650 |
@file:SuppressLint("SoonBlockedPrivateApi")
package io.nekohasekai.sagernet.ktx
import android.animation.Animator
import android.animation.AnimatorListenerAdapter
import android.annotation.SuppressLint
import android.content.*
import android.content.pm.PackageInfo
import android.content.res.Resources
import android.os.Build
import android.system.Os
import android.system.OsConstants
import android.util.TypedValue
import android.view.View
import androidx.activity.result.ActivityResultLauncher
import androidx.annotation.AttrRes
import androidx.annotation.ColorRes
import androidx.core.content.ContextCompat
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentManager
import androidx.preference.Preference
import androidx.recyclerview.widget.LinearSmoothScroller
import androidx.recyclerview.widget.RecyclerView
import com.jakewharton.processphoenix.ProcessPhoenix
import io.nekohasekai.sagernet.BuildConfig
import io.nekohasekai.sagernet.R
import io.nekohasekai.sagernet.SagerNet
import io.nekohasekai.sagernet.bg.Executable
import io.nekohasekai.sagernet.database.DataStore
import io.nekohasekai.sagernet.database.SagerDatabase
import io.nekohasekai.sagernet.database.preference.PublicDatabase
import io.nekohasekai.sagernet.ui.MainActivity
import io.nekohasekai.sagernet.ui.ThemedActivity
import kotlinx.coroutines.*
import moe.matsuri.nb4a.utils.NGUtil
import java.io.FileDescriptor
import java.net.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicLong
import java.util.concurrent.atomic.AtomicReference
import kotlin.coroutines.Continuation
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.reflect.KMutableProperty0
import kotlin.reflect.KProperty
import kotlin.reflect.KProperty0
inline fun <T> Iterable<T>.forEachTry(action: (T) -> Unit) {
var result: Exception? = null
for (element in this) try {
action(element)
} catch (e: Exception) {
if (result == null) result = e else result.addSuppressed(e)
}
if (result != null) {
throw result
}
}
val Throwable.readableMessage
get() = localizedMessage.takeIf { !it.isNullOrBlank() } ?: javaClass.simpleName
/**
* https://android.googlesource.com/platform/prebuilts/runtime/+/94fec32/appcompat/hiddenapi-light-greylist.txt#9466
*/
private val socketGetFileDescriptor = Socket::class.java.getDeclaredMethod("getFileDescriptor\$")
val Socket.fileDescriptor get() = socketGetFileDescriptor.invoke(this) as FileDescriptor
private val getInt = FileDescriptor::class.java.getDeclaredMethod("getInt$")
val FileDescriptor.int get() = getInt.invoke(this) as Int
suspend fun <T> HttpURLConnection.useCancellable(block: suspend HttpURLConnection.() -> T): T {
return suspendCancellableCoroutine { cont ->
cont.invokeOnCancellation {
if (Build.VERSION.SDK_INT >= 26) disconnect() else GlobalScope.launch(Dispatchers.IO) { disconnect() }
}
GlobalScope.launch(Dispatchers.IO) {
try {
cont.resume(block())
} catch (e: Throwable) {
cont.resumeWithException(e)
}
}
}
}
fun parsePort(str: String?, default: Int, min: Int = 1025): Int {
val value = str?.toIntOrNull() ?: default
return if (value < min || value > 65535) default else value
}
fun broadcastReceiver(callback: (Context, Intent) -> Unit): BroadcastReceiver =
object : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) = callback(context, intent)
}
fun Context.listenForPackageChanges(onetime: Boolean = true, callback: () -> Unit) =
object : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
callback()
if (onetime) context.unregisterReceiver(this)
}
}.apply {
registerReceiver(this, IntentFilter().apply {
addAction(Intent.ACTION_PACKAGE_ADDED)
addAction(Intent.ACTION_PACKAGE_REMOVED)
addDataScheme("package")
})
}
val PackageInfo.signaturesCompat
get() = if (Build.VERSION.SDK_INT >= 28) signingInfo.apkContentsSigners else @Suppress("DEPRECATION") signatures
/**
* Based on: https://stackoverflow.com/a/26348729/2245107
*/
fun Resources.Theme.resolveResourceId(@AttrRes resId: Int): Int {
val typedValue = TypedValue()
if (!resolveAttribute(resId, typedValue, true)) throw Resources.NotFoundException()
return typedValue.resourceId
}
fun Preference.remove() = parent!!.removePreference(this)
/**
* A slightly more performant variant of parseNumericAddress.
*
* Bug in Android 9.0 and lower: https://issuetracker.google.com/issues/123456213
*/
private val parseNumericAddress by lazy {
InetAddress::class.java.getDeclaredMethod("parseNumericAddress", String::class.java).apply {
isAccessible = true
}
}
fun String?.parseNumericAddress(): InetAddress? =
Os.inet_pton(OsConstants.AF_INET, this) ?: Os.inet_pton(OsConstants.AF_INET6, this)?.let {
if (Build.VERSION.SDK_INT >= 29) it else parseNumericAddress.invoke(
null, this
) as InetAddress
}
@JvmOverloads
fun DialogFragment.showAllowingStateLoss(fragmentManager: FragmentManager, tag: String? = null) {
if (!fragmentManager.isStateSaved) show(fragmentManager, tag)
}
fun String.pathSafe(): String {
// " " encoded as +
return URLEncoder.encode(this, "UTF-8")
}
fun String.urlSafe(): String {
return URLEncoder.encode(this, "UTF-8").replace("+", "%20")
}
fun String.unUrlSafe(): String {
return NGUtil.urlDecode(this)
}
fun RecyclerView.scrollTo(index: Int, force: Boolean = false) {
if (force) post {
scrollToPosition(index)
}
postDelayed({
try {
layoutManager?.startSmoothScroll(object : LinearSmoothScroller(context) {
init {
targetPosition = index
}
override fun getVerticalSnapPreference(): Int {
return SNAP_TO_START
}
})
} catch (ignored: IllegalArgumentException) {
}
}, 300L)
}
val app get() = SagerNet.application
val shortAnimTime by lazy {
app.resources.getInteger(android.R.integer.config_shortAnimTime).toLong()
}
fun View.crossFadeFrom(other: View) {
clearAnimation()
other.clearAnimation()
if (visibility == View.VISIBLE && other.visibility == View.GONE) return
alpha = 0F
visibility = View.VISIBLE
animate().alpha(1F).duration = shortAnimTime
other.animate().alpha(0F).setListener(object : AnimatorListenerAdapter() {
override fun onAnimationEnd(animation: Animator) {
other.visibility = View.GONE
}
}).duration = shortAnimTime
}
fun Fragment.snackbar(textId: Int) = (requireActivity() as MainActivity).snackbar(textId)
fun Fragment.snackbar(text: CharSequence) = (requireActivity() as MainActivity).snackbar(text)
fun ThemedActivity.startFilesForResult(
launcher: ActivityResultLauncher<String>, input: String
) {
try {
return launcher.launch(input)
} catch (_: ActivityNotFoundException) {
} catch (_: SecurityException) {
}
snackbar(getString(R.string.file_manager_missing)).show()
}
fun Fragment.startFilesForResult(
launcher: ActivityResultLauncher<String>, input: String
) {
try {
return launcher.launch(input)
} catch (_: ActivityNotFoundException) {
} catch (_: SecurityException) {
}
(requireActivity() as ThemedActivity).snackbar(getString(R.string.file_manager_missing)).show()
}
fun Fragment.needReload() {
if (DataStore.serviceState.started) {
snackbar(getString(R.string.need_reload)).setAction(R.string.apply) {
SagerNet.reloadService()
}.show()
}
}
fun Fragment.needRestart() {
snackbar(R.string.need_restart).setAction(R.string.apply) {
SagerNet.stopService()
val ctx = requireContext()
runOnDefaultDispatcher {
delay(500)
SagerDatabase.instance.close()
PublicDatabase.instance.close()
Executable.killAll(true)
ProcessPhoenix.triggerRebirth(ctx, Intent(ctx, MainActivity::class.java))
}
}.show()
}
fun Context.getColour(@ColorRes colorRes: Int): Int {
return ContextCompat.getColor(this, colorRes)
}
fun Context.getColorAttr(@AttrRes resId: Int): Int {
return ContextCompat.getColor(this, TypedValue().also {
theme.resolveAttribute(resId, it, true)
}.resourceId)
}
val isExpert: Boolean by lazy { BuildConfig.DEBUG || DataStore.isExpert }
val isExpertFlavor = ((BuildConfig.FLAVOR == "expert") || BuildConfig.DEBUG)
const val isOss = BuildConfig.FLAVOR == "oss"
const val isFdroid = BuildConfig.FLAVOR == "fdroid"
const val isPlay = BuildConfig.FLAVOR == "play"
fun <T> Continuation<T>.tryResume(value: T) {
try {
resumeWith(Result.success(value))
} catch (ignored: IllegalStateException) {
}
}
fun <T> Continuation<T>.tryResumeWithException(exception: Throwable) {
try {
resumeWith(Result.failure(exception))
} catch (ignored: IllegalStateException) {
}
}
operator fun <F> KProperty0<F>.getValue(thisRef: Any?, property: KProperty<*>): F = get()
operator fun <F> KMutableProperty0<F>.setValue(
thisRef: Any?, property: KProperty<*>, value: F
) = set(value)
operator fun AtomicBoolean.getValue(thisRef: Any?, property: KProperty<*>): Boolean = get()
operator fun AtomicBoolean.setValue(thisRef: Any?, property: KProperty<*>, value: Boolean) =
set(value)
operator fun AtomicInteger.getValue(thisRef: Any?, property: KProperty<*>): Int = get()
operator fun AtomicInteger.setValue(thisRef: Any?, property: KProperty<*>, value: Int) = set(value)
operator fun AtomicLong.getValue(thisRef: Any?, property: KProperty<*>): Long = get()
operator fun AtomicLong.setValue(thisRef: Any?, property: KProperty<*>, value: Long) = set(value)
operator fun <T> AtomicReference<T>.getValue(thisRef: Any?, property: KProperty<*>): T = get()
operator fun <T> AtomicReference<T>.setValue(thisRef: Any?, property: KProperty<*>, value: T) =
set(value)
operator fun <K, V> Map<K, V>.getValue(thisRef: K, property: KProperty<*>) = get(thisRef)
operator fun <K, V> MutableMap<K, V>.setValue(thisRef: K, property: KProperty<*>, value: V?) {
if (value != null) {
put(thisRef, value)
} else {
remove(thisRef)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Utils.kt | 3257266144 |
package io.nekohasekai.sagernet.ktx
import libcore.Libcore
import java.io.InputStream
import java.io.OutputStream
object Logs {
private fun mkTag(): String {
val stackTrace = Thread.currentThread().stackTrace
return stackTrace[4].className.substringAfterLast(".")
}
// level int use logrus.go
fun d(message: String) {
Libcore.nekoLogPrintln("[Debug] [${mkTag()}] $message")
}
fun d(message: String, exception: Throwable) {
Libcore.nekoLogPrintln("[Debug] [${mkTag()}] $message" + "\n" + exception.stackTraceToString())
}
fun i(message: String) {
Libcore.nekoLogPrintln("[Info] [${mkTag()}] $message")
}
fun i(message: String, exception: Throwable) {
Libcore.nekoLogPrintln("[Info] [${mkTag()}] $message" + "\n" + exception.stackTraceToString())
}
fun w(message: String) {
Libcore.nekoLogPrintln("[Warning] [${mkTag()}] $message")
}
fun w(message: String, exception: Throwable) {
Libcore.nekoLogPrintln("[Warning] [${mkTag()}] $message" + "\n" + exception.stackTraceToString())
}
fun w(exception: Throwable) {
Libcore.nekoLogPrintln("[Warning] [${mkTag()}] " + exception.stackTraceToString())
}
fun e(message: String) {
Libcore.nekoLogPrintln("[Error] [${mkTag()}] $message")
}
fun e(message: String, exception: Throwable) {
Libcore.nekoLogPrintln("[Error] [${mkTag()}] $message" + "\n" + exception.stackTraceToString())
}
fun e(exception: Throwable) {
Libcore.nekoLogPrintln("[Error] [${mkTag()}] " + exception.stackTraceToString())
}
}
fun InputStream.use(out: OutputStream) {
use { input ->
out.use { output ->
input.copyTo(output)
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Logs.kt | 919610601 |
package io.nekohasekai.sagernet.ktx
import libcore.StringIterator
fun Iterable<String>.toStringIterator(): StringIterator {
return object : StringIterator {
val iterator = iterator()
override fun hasNext(): Boolean {
return iterator.hasNext()
}
override fun next(): String {
return iterator.next()
}
}
}
fun StringIterator.toList(): List<String> {
return mutableListOf<String>().apply {
while (hasNext()) {
add(next())
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Wrappers.kt | 1628030546 |
package io.nekohasekai.sagernet.ktx
import android.content.Context
import android.net.Uri
import androidx.browser.customtabs.CustomTabColorSchemeParams
import androidx.browser.customtabs.CustomTabsIntent
import io.nekohasekai.sagernet.R
fun Context.launchCustomTab(link: String) {
CustomTabsIntent.Builder().apply {
setColorScheme(CustomTabsIntent.COLOR_SCHEME_SYSTEM)
setColorSchemeParams(
CustomTabsIntent.COLOR_SCHEME_LIGHT,
CustomTabColorSchemeParams.Builder().apply {
setToolbarColor(getColorAttr(R.attr.colorPrimary))
}.build()
)
setColorSchemeParams(
CustomTabsIntent.COLOR_SCHEME_DARK,
CustomTabColorSchemeParams.Builder().apply {
setToolbarColor(getColorAttr(R.attr.colorPrimary))
}.build()
)
}.build().apply {
if (intent.resolveActivity(packageManager) != null) {
launchUrl(this@launchCustomTab, Uri.parse(link))
}
}
} | nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Browsers.kt | 1755406507 |
@file:Suppress("SpellCheckingInspection")
package io.nekohasekai.sagernet.ktx
import io.nekohasekai.sagernet.BuildConfig
import io.nekohasekai.sagernet.fmt.AbstractBean
import moe.matsuri.nb4a.utils.NGUtil
import okhttp3.HttpUrl
import java.net.InetSocketAddress
import java.net.Socket
fun linkBuilder() = HttpUrl.Builder().scheme("https")
fun HttpUrl.Builder.toLink(scheme: String, appendDefaultPort: Boolean = true): String {
var url = build()
val defaultPort = HttpUrl.defaultPort(url.scheme)
var replace = false
if (appendDefaultPort && url.port == defaultPort) {
url = url.newBuilder().port(14514).build()
replace = true
}
return url.toString().replace("${url.scheme}://", "$scheme://").let {
if (replace) it.replace(":14514", ":$defaultPort") else it
}
}
fun String.isIpAddress(): Boolean {
return NGUtil.isIpv4Address(this) || NGUtil.isIpv6Address(this)
}
fun String.isIpAddressV6(): Boolean {
return NGUtil.isIpv6Address(this)
}
// [2001:4860:4860::8888] -> 2001:4860:4860::8888
fun String.unwrapIPV6Host(): String {
if (startsWith("[") && endsWith("]")) {
return substring(1, length - 1).unwrapIPV6Host()
}
return this
}
// [2001:4860:4860::8888] or 2001:4860:4860::8888 -> [2001:4860:4860::8888]
fun String.wrapIPV6Host(): String {
val unwrapped = this.unwrapIPV6Host()
if (unwrapped.isIpAddressV6()) {
return "[$unwrapped]"
} else {
return this
}
}
fun AbstractBean.wrapUri(): String {
return "${finalAddress.wrapIPV6Host()}:$finalPort"
}
fun mkPort(): Int {
val socket = Socket()
socket.reuseAddress = true
socket.bind(InetSocketAddress(0))
val port = socket.localPort
socket.close()
return port
}
const val USER_AGENT = "NekoBox/Android/" + BuildConfig.VERSION_NAME + " (Prefer ClashMeta Format)"
| nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Nets.kt | 2848353472 |
package io.nekohasekai.sagernet.ktx
import android.content.res.Resources
import kotlin.math.ceil
private val density = Resources.getSystem().displayMetrics.density
fun dp2pxf(dpValue: Int): Float {
return density * dpValue
}
fun dp2px(dpValue: Int): Int {
return ceil(dp2pxf(dpValue)).toInt()
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Dimens.kt | 2236369556 |
package io.nekohasekai.sagernet.ktx
import android.app.Activity
import android.content.Context
import androidx.appcompat.app.AlertDialog
import androidx.fragment.app.Fragment
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import io.nekohasekai.sagernet.R
fun Context.alert(text: String): AlertDialog {
return MaterialAlertDialogBuilder(this).setTitle(R.string.error_title)
.setMessage(text)
.setPositiveButton(android.R.string.ok, null)
.create()
}
fun Fragment.alert(text: String) = requireContext().alert(text)
fun AlertDialog.tryToShow() {
try {
val activity = context as Activity
if (!activity.isFinishing) {
show()
}
} catch (e: Exception) {
Logs.e(e)
}
}
| nacs/app/src/main/java/io/nekohasekai/sagernet/ktx/Dialogs.kt | 1139498952 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.