path
stringlengths 4
297
| contentHash
stringlengths 1
10
| content
stringlengths 0
13M
|
|---|---|---|
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/utils/Constants.kt | 1369258272 | package com.thezayin.chatbottesting.utils
object Constants {
val BASE_URL = "http://api.brainshop.ai/"
} |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/data/botapi/BotApi.kt | 3659504589 | package com.thezayin.chatbottesting.data.botapi
import com.thezayin.chatbottesting.domain.model.Message
import com.thezayin.chatbottesting.utils.Response
import retrofit2.http.GET
import retrofit2.http.Query
interface BotApi {
@GET("/get?bid=180701&key=HNALinzc2atw9sWA&uid=[uid]")
suspend fun sendMessage(@Query("msg") msg: String): Message
} |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/data/BotRepositoryImpl.kt | 3901104756 | package com.thezayin.chatbottesting.data
import com.thezayin.chatbottesting.data.botapi.BotApi
import com.thezayin.chatbottesting.domain.model.Message
import com.thezayin.chatbottesting.domain.repo.BotRepository
import javax.inject.Inject
class BotRepositoryImpl @Inject constructor(private val botApi: BotApi) : BotRepository {
override suspend fun sendMessage(string: String): Message {
return botApi.sendMessage(string)
}
} |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/domain/model/Message.kt | 2705761382 | package com.thezayin.chatbottesting.domain.model
data class Message(
val sender:String?,
val cnt: String
) |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/domain/usecase/BotUseCase.kt | 3418155207 | package com.thezayin.chatbottesting.domain.usecase
import android.net.http.HttpException
import android.os.Build
import android.util.Log
import androidx.annotation.RequiresExtension
import com.thezayin.chatbottesting.domain.model.Message
import com.thezayin.chatbottesting.domain.repo.BotRepository
import com.thezayin.chatbottesting.utils.Response
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import java.io.IOException
import javax.inject.Inject
class BotUseCase @Inject constructor(
private val botRepository: BotRepository
) {
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
operator fun invoke(message: String): Flow<Response<Message>> = flow {
try {
emit(Response.Loading)
val response = botRepository.sendMessage(message)
emit(Response.Success(response))
} catch (e: HttpException) {
emit(Response.Failure(e.localizedMessage ?: "Unexpected Error"))
} catch (e: IOException) {
emit(Response.Failure(e.localizedMessage ?: "Unexpected Error"))
}
}
} |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/domain/usecase/MessageUseCases.kt | 3108555749 | package com.thezayin.chatbottesting.domain.usecase
data class MessageUseCases(
val botUseCase: BotUseCase
) |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/domain/repo/BotRepository.kt | 1963273717 | package com.thezayin.chatbottesting.domain.repo
import com.thezayin.chatbottesting.domain.model.Message
import com.thezayin.chatbottesting.utils.Response
import kotlinx.coroutines.flow.Flow
interface BotRepository {
suspend fun sendMessage(string: String): Message
} |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/presentation/component/TopBar.kt | 3220865893 | package com.thezayin.chatbottesting.presentation.component
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.colorResource
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.thezayin.chatbottesting.R
@Composable
fun TopBar(modifier: Modifier, title: String, callBack: () -> Unit) {
Box(
modifier = modifier
.background(colorResource(id = R.color.white))
.fillMaxWidth()
.padding(20.dp)
) {
Image(painter = painterResource(id = R.drawable.ic_back),
contentDescription = "",
modifier = Modifier
.size(22.dp)
.fillMaxHeight()
.align(Alignment.CenterStart)
.clickable {
callBack()
})
Text(
text = title,
fontSize = 24.sp,
color = colorResource(id = R.color.text_color),
fontWeight = FontWeight.Medium,
// fontFamily = FontFamily(Font(R.font.nunito_extrabold)),
modifier = Modifier
.align(alignment = Alignment.Center)
)
}
} |
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/presentation/component/MessageBody.kt | 1003092203 | package com.thezayin.chatbottesting.presentation.component
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.layout.wrapContentWidth
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.colorResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import com.thezayin.chatbottesting.R
import com.thezayin.chatbottesting.domain.model.Message
@Composable
fun MessageBody(message: Message) {
Box(
modifier = Modifier.fillMaxWidth()
) {
Card(
colors = CardDefaults.cardColors(
if (message.sender.equals("bot")) colorResource(id = R.color.ed_background) else colorResource(
id = R.color.primary
),
),
modifier = Modifier
.padding(10.dp)
.wrapContentWidth()
.widthIn(min = 50.dp, max = 300.dp)
.align(if (message.sender.equals("bot")) Alignment.CenterStart else Alignment.CenterEnd),
shape = RoundedCornerShape(
topStart = if (message.sender.equals("bot")) 0.dp else 24.dp,
topEnd = 24.dp,
bottomEnd = if (message.sender.equals("bot")) 24.dp else 0.dp,
bottomStart = 24.dp,
),
elevation = CardDefaults.cardElevation(1.dp)
) {
Box(
modifier = Modifier, contentAlignment = Alignment.Center
) {
Text(
text = message.cnt,
textAlign = TextAlign.Center,
color = if (message.sender.equals("bot")) Color.Black else Color.White,
modifier = Modifier
.padding(horizontal = 20.dp, vertical = 10.dp)
.wrapContentHeight(Alignment.CenterVertically)
)
}
}
}
}
|
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/presentation/component/ChatBox.kt | 2632215884 | package com.thezayin.chatbottesting.presentation.component
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.IconButtonDefaults
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.OutlinedTextFieldDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.colorResource
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.thezayin.chatbottesting.R
import com.thezayin.chatbottesting.presentation.ChatViewModel
import kotlinx.coroutines.launch
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun ChatBox(modifier: Modifier, chatViewModel: ChatViewModel, listState: LazyListState) {
var chatBoxValue by remember { mutableStateOf(TextFieldValue("")) }
val coroutineScope = rememberCoroutineScope()
Row(
modifier = modifier
.fillMaxWidth()
.background(color = Color.White)
.padding(horizontal = 10.dp)
.padding(bottom = 15.dp),
horizontalArrangement = Arrangement.SpaceAround,
verticalAlignment = Alignment.Bottom
) {
OutlinedTextField(
value = chatBoxValue,
onValueChange = { newText ->
chatBoxValue = newText
},
placeholder = {
Text(
text = "Type a message...",
color = colorResource(id = R.color.grey),
fontSize = 16.sp,
modifier = Modifier.padding(horizontal = 5.dp)
)
},
modifier = Modifier
.heightIn(45.dp)
.fillMaxWidth(0.8f)
.padding(0.dp, 10.dp, 0.dp, 0.dp),
shape = RoundedCornerShape(48.dp),
colors = OutlinedTextFieldDefaults.colors(
focusedBorderColor = colorResource(id = R.color.primary),
focusedTextColor = colorResource(id = R.color.black),
unfocusedTextColor = colorResource(id = R.color.black),
unfocusedBorderColor = colorResource(id = R.color.primary),
),
)
IconButton(
modifier = Modifier
.size(55.dp),
colors = IconButtonDefaults.iconButtonColors(
containerColor = colorResource(id = R.color.btn_primary),
contentColor = Color.White
),
onClick = {
chatViewModel.sendMessage(message = chatBoxValue.text, user = "user")
chatBoxValue = TextFieldValue("")
coroutineScope.launch {
listState.animateScrollToItem(index = 30)
}
}
) {
Icon(
painter = painterResource(id = R.drawable.ic_send),
contentDescription = null,
modifier = Modifier.size(25.dp)
)
}
}
}
|
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/presentation/ChatScreen.kt | 2748391254 | package com.thezayin.chatbottesting.presentation
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.colorResource
import androidx.hilt.navigation.compose.hiltViewModel
import com.thezayin.chatbottesting.R
import com.thezayin.chatbottesting.presentation.component.ChatBox
import com.thezayin.chatbottesting.presentation.component.MessageBody
import com.thezayin.chatbottesting.presentation.component.TopBar
@OptIn(ExperimentalComposeUiApi::class)
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun ChatScreen() {
val chatViewModel: ChatViewModel = hiltViewModel()
val listState = rememberLazyListState()
Scaffold(modifier = Modifier
.fillMaxSize(),
containerColor = colorResource(id = R.color.white),
topBar = {
TopBar(modifier = Modifier, title = "Chat Bot") {}
},
bottomBar = {
ChatBox(
modifier = Modifier,
chatViewModel = chatViewModel,
listState = listState
)
}
) { padding ->
LazyColumn(
modifier = Modifier
.fillMaxWidth()
.background(color = colorResource(id = R.color.white))
.padding(padding),
contentPadding = PaddingValues(),
state = listState
) {
items(chatViewModel._messageState.size) { message ->
MessageBody(message = chatViewModel._messageState[message])
}
}
}
}
|
Brainshop-chatbot-app/app/src/main/java/com/thezayin/chatbottesting/presentation/ChatViewModel.kt | 2744056827 | package com.thezayin.chatbottesting.presentation
import android.os.Build
import android.util.Log
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.mutableStateListOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.thezayin.chatbottesting.domain.model.Message
import com.thezayin.chatbottesting.domain.usecase.MessageUseCases
import com.thezayin.chatbottesting.utils.Response
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class ChatViewModel @Inject constructor(
private val useCase: MessageUseCases
) : ViewModel() {
var _messageState = mutableStateListOf<Message>()
private set
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
fun sendMessage(message: String, user: String) {
_messageState.add(Message(sender = user, cnt = message))
viewModelScope.launch {
useCase.botUseCase(message).collect { response ->
when (response) {
is Response.Success -> {
_messageState.add(
response.data.copy(
sender = "bot",
cnt = response.data.cnt
)
)
Log.d("ChatViewModel", "sendMessage: ${_messageState}")
}
is Response.Failure -> {
Log.d("ChatViewModel", "sendMessage: ${response.e}")
}
is Response.Loading -> {
Log.d("ChatViewModel", "sendMessage: ${response}")
}
}
}
}
}
} |
DemoFoMtu/app/src/androidTest/java/com/au/demoformtu/ExampleInstrumentedTest.kt | 3323810277 | package com.au.demoformtu
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.au.demoformtu", appContext.packageName)
}
} |
DemoFoMtu/app/src/test/java/com/au/demoformtu/ExampleUnitTest.kt | 1279184186 | package com.au.demoformtu
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} |
DemoFoMtu/app/src/main/java/com/au/demoformtu/MainActivity.kt | 3332445558 | package com.au.demoformtu
import android.annotation.SuppressLint
import android.bluetooth.BluetoothManager
import android.content.Context
import android.os.Bundle
import android.util.Log
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import com.au.demoformtu.BlePermissionHelp.blePermissions
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import java.util.Locale
class MainActivity : AppCompatActivity() {
companion object {
const val TAG = "DemoMtu"
var logChangeCallback:IShowTextCallback? = null
private val logs = mutableListOf<String>()
fun updateLog(log:String, clearLog:Boolean = false) {
val sb = StringBuilder()
synchronized(logs) {
if (clearLog) {
logs.clear()
}
logs.add(log)
logs.forEach {
sb.append(it).append("\n\n")
}
}
logChangeCallback?.onText(sb.toString())
}
var inputAddress:String? = null
}
lateinit var bluetoothManager: BluetoothManager
private val blePermissionHelper = multiplePermissionsForResult()
val activityHelper = activityForResult()
private val scanDevice = ScanBluetoothDevice(this)
private lateinit var showText:TextView
private lateinit var editText:EditText
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
bluetoothManager = getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
setContentView(R.layout.activity_main)
showText = findViewById(R.id.showText)
editText = findViewById(R.id.edit)
findViewById<Button>(R.id.sureBtn).setOnClickListener {
val address = editText.text.toString().uppercase(Locale.ROOT)
inputAddress = address
saveAddressToSp(address)
checkPermission(true)
}
logChangeCallback = object : IShowTextCallback {
override fun onText(str: String) {
lifecycleScope.launch {
showText.text = str
}
}
}
}
private var isResumeCount = 0
override fun onResume() {
super.onResume()
if (isResumeCount == 0) {
val address = readAddressFromSp()?.uppercase(Locale.ROOT)
if (!address.isNullOrEmpty()) {
editText.setText(address)
inputAddress = address
}
checkPermission(true)
}
isResumeCount++
}
private fun checkPermission(jumpToApp:Boolean) {
if (BlePermissionHelp.isPermissionGrant(this)) {
showText.text = "Has Permission, start ble Scan..."
startBleScan()
} else {
val canShow = BlePermissionHelp.canShowRequestDialogUi(this)
Log.w(TAG, "request permission!!! canShowDialog $canShow")
showText.text = "request permission!!! canShowDialog $canShow"
if (!canShow) {
showText.text = "no permission!!!It will jump to appDetail in 5s..."
Toast.makeText(this, "$TAG Please give the bluetooth permission!", Toast.LENGTH_LONG).show()
if (jumpToApp) {
lifecycleScope.launch {
delay(5000)
activityHelper.jumpToAppDetail(this@MainActivity) {
checkPermission(false)
}
}
}
} else {
BlePermissionHelp.requestPermission2(blePermissionHelper, blePermissions) {
Log.w(TAG, "request permission... $it")
if (it) {
startBleScan()
}
}
}
}
}
@SuppressLint("MissingPermission")
private fun startBleScan() {
Log.w(TAG, "start ble Scan! $inputAddress")
lifecycleScope.launch(Dispatchers.IO) {
delay(3000)
val isSuc = scanDevice.scan(bluetoothManager)
if (isSuc) {
updateLog("start ble Scan! $inputAddress", true)
} else {
updateLog("start ble Scan! no inputAddress.", true)
}
}
}
private fun saveAddressToSp(address:String) {
val sp = this.getSharedPreferences("save_address", Context.MODE_PRIVATE)
sp.edit().putString("address", address).apply()
}
private fun readAddressFromSp(): String? {
val sp = this.getSharedPreferences("save_address", Context.MODE_PRIVATE)
return sp.getString("address", "")
}
} |
DemoFoMtu/app/src/main/java/com/au/demoformtu/ActivityResultUtil.kt | 2991354304 | package com.au.demoformtu
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import android.provider.Settings
import androidx.activity.result.ActivityResult
import androidx.activity.result.ActivityResultCallback
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContract
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityOptionsCompat
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import androidx.lifecycle.DefaultLifecycleObserver
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleOwner
fun LifecycleOwner.multiplePermissionsForResult() =
activityResultHelper(lifecycle, ActivityResultContracts.RequestMultiplePermissions())
fun LifecycleOwner.permissionForResult() =
activityResultHelper(lifecycle, ActivityResultContracts.RequestPermission())
fun LifecycleOwner.activityForResult() =
activityResultHelper(lifecycle, ActivityResultContracts.StartActivityForResult())
fun <I, O> activityResultHelper(
lifecycle: Lifecycle,
resultContract: ActivityResultContract<I, O>
) =
ActivityResultHelper(resultContract).also {
lifecycle.addObserver(it)
}
open class ActivityResultHelper<I, O>(val resultContract: ActivityResultContract<I, O>) :
DefaultLifecycleObserver, ActivityResultCallback<O> {
private var launcher: ActivityResultLauncher<I>? = null
val resultLauncher
get() = launcher
private var onResult: ((O) -> Unit)? = null
override fun onCreate(owner: LifecycleOwner) {
super.onCreate(owner)
launcher = when (owner) {
is AppCompatActivity -> {
owner.registerForActivityResult(resultContract, this)
}
is Fragment -> {
owner.registerForActivityResult(resultContract, this)
}
else -> {
null
}
}
}
override fun onDestroy(owner: LifecycleOwner) {
super.onDestroy(owner)
onResult = null
launcher?.unregister()
launcher = null
}
override fun onActivityResult(result: O) {
onResult?.invoke(result)
}
fun launch(
intent: I,
option: ActivityOptionsCompat? = null,
block: (O) -> Unit
) {
this.onResult = block
launcher?.launch(intent, option)
}
}
fun String.hasPermission(context: Context): Boolean {
return ContextCompat.checkSelfPermission(
context.applicationContext,
this
) == PackageManager.PERMISSION_GRANTED
}
fun List<String>.checkPermission(context: Context): MutableList<String> {
val noPermission = mutableListOf<String>()
forEach {
if (!it.hasPermission(context)) {
noPermission.add(it)
}
}
return noPermission
}
fun List<String>.hasPermission(context: Context): Boolean {
return checkPermission(context).isEmpty()
}
fun Array<String>.checkPermission(context: Context): MutableList<String> {
val noPermission = mutableListOf<String>()
forEach {
if (!it.hasPermission(context)) {
noPermission.add(it)
}
}
return noPermission
}
fun Array<String>.hasPermission(context: Context): Boolean {
return checkPermission(context).isEmpty()
}
fun ActivityResultHelper<Intent, ActivityResult>.jumpToAppDetail(appContext: Context, afterBackAppBlock:((ActivityResult)->Unit)? = null) {
val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
intent.data = Uri.fromParts("package", appContext.packageName, null)
launch(intent) {
afterBackAppBlock?.invoke(it)
}
}
|
DemoFoMtu/app/src/main/java/com/au/demoformtu/GattCallback.kt | 299486664 | package com.au.demoformtu
import android.annotation.SuppressLint
import android.bluetooth.BluetoothGatt
import android.bluetooth.BluetoothGattCallback
import android.bluetooth.BluetoothGattCharacteristic
import android.bluetooth.BluetoothGattService
import android.bluetooth.BluetoothProfile
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch
import java.util.UUID
import android.util.Log
import com.au.demoformtu.MainActivity.Companion.updateLog
class GattCallback(val activity: AppCompatActivity) : BluetoothGattCallback() {
val UUID_WRITE_CHARACTERISTIC = UUID.fromString("0000ff01-0000-1000-8000-00805f9b34fb")
val UUID_NOTIFICATION_CHARACTERISTIC = UUID.fromString("0000ff02-0000-1000-8000-00805f9b34fb")
val UUID_SERVICE = UUID.fromString("0000ffff-0000-1000-8000-00805f9b34fb")
@SuppressLint("MissingPermission")
override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
super.onConnectionStateChange(gatt, status, newState)
val isSuc = status == BluetoothGatt.GATT_SUCCESS
updateLog("onConnectionStateChange() status $status, GATT_SUCCESS $isSuc, newState $newState")
if (isSuc) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
gatt!!.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH)
gatt.discoverServices()
}
}
}
@SuppressLint("MissingPermission")
override fun onServicesDiscovered(gatt: BluetoothGatt?, status: Int) {
super.onServicesDiscovered(gatt, status)
var service: BluetoothGattService? = null
var writeChar: BluetoothGattCharacteristic? = null
var notifyChar: BluetoothGattCharacteristic? = null
val isSuc = status == BluetoothGatt.GATT_SUCCESS
updateLog("onServicesDiscovered() status $status success:$isSuc")
if (isSuc) {
service = gatt!!.getService(UUID_SERVICE)
if (service != null) {
writeChar = service.getCharacteristic(UUID_WRITE_CHARACTERISTIC)
notifyChar = service.getCharacteristic(UUID_NOTIFICATION_CHARACTERISTIC)
if (notifyChar != null) {
gatt.setCharacteristicNotification(notifyChar, true)
}
}
activity.lifecycleScope.launch {
val mtu: Int = 251
updateLog("requestMtu() $mtu")
Log.w(MainActivity.TAG, "try to requestMtu >>> try to requestMtu")
val requestMtu = gatt!!.requestMtu(mtu)
updateLog("requestMtu() isSuccess $requestMtu")
Log.w(MainActivity.TAG, "requestMtu() isSuccess $requestMtu")
}
}
}
override fun onMtuChanged(gatt: BluetoothGatt?, mtu: Int, status: Int) {
super.onMtuChanged(gatt, mtu, status)
Log.w(MainActivity.TAG, "onMtuChanged() status=$status, mtu= $mtu")
updateLog("onMtuChanged() status=$status, mtu= $mtu")
}
} |
DemoFoMtu/app/src/main/java/com/au/demoformtu/BlePermissionHelp.kt | 1319149393 | package com.au.demoformtu
import android.Manifest
import android.content.Context
import android.os.Build
import androidx.core.app.ActivityCompat
import androidx.fragment.app.FragmentActivity
object BlePermissionHelp {
val blePermissions =
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
arrayOf(
Manifest.permission.BLUETOOTH_SCAN,
Manifest.permission.BLUETOOTH_CONNECT,)
else
arrayOf(
Manifest.permission.BLUETOOTH,
Manifest.permission.BLUETOOTH_ADMIN,
Manifest.permission.ACCESS_FINE_LOCATION,)
fun canShowRequestDialogUi(activity: FragmentActivity) : Boolean{
for (permission in blePermissions) {
if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
return true
}
}
return false
}
inline fun safeRun(
helper: ActivityResultHelper<Array<String>, Map<String, @JvmSuppressWildcards Boolean>>,
crossinline block: () -> Unit
) {
requestPermission(helper, permissionList = blePermissions) {
block.invoke()
}
}
fun isPermissionGrant(context: Context): Boolean {
return blePermissions.hasPermission(context)
}
fun requestPermission(
permission: ActivityResultHelper<Array<String>, Map<String, @JvmSuppressWildcards Boolean>>,
permissionList: Array<String>,
block: () -> Unit
) {
permission.launch(permissionList) {
var hasPermission = false
for (entry in it) {
if (!entry.value) {
hasPermission = false
break
} else {
hasPermission = true
}
}
if (hasPermission) block.invoke()
}
}
fun requestPermission2(
permission: ActivityResultHelper<Array<String>, Map<String, @JvmSuppressWildcards Boolean>>,
permissionList: Array<String>,
block: (Boolean) -> Unit
) {
permission.launch(permissionList) {
var hasPermission = false
for (entry in it) {
if (!entry.value) {
hasPermission = false
break
} else {
hasPermission = true
}
}
block.invoke(hasPermission)
}
}
} |
DemoFoMtu/app/src/main/java/com/au/demoformtu/ScanBluetoothDevice.kt | 1020709130 | package com.au.demoformtu
import android.annotation.SuppressLint
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothManager
import android.os.Build
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import com.au.demoformtu.MainActivity.Companion.updateLog
import kotlinx.coroutines.delay
import java.util.Locale
class ScanBluetoothDevice(private val activity: AppCompatActivity) {
@SuppressLint("MissingPermission")
suspend fun scan(bluetoothManager: BluetoothManager) : Boolean{
var address = MainActivity.inputAddress ?: return false
address = address.uppercase(Locale.ROOT)
val bluetoothDevice = getBluetoothDevice(bluetoothManager, address, true)
Log.d(MainActivity.TAG, "bluetoothDevice $address device:${bluetoothDevice?.address}")
updateLog("bluetoothDevice $address device:${bluetoothDevice?.address}")
val gatt = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
bluetoothDevice?.connectGatt(activity, false, GattCallback(activity), BluetoothDevice.TRANSPORT_LE)
} else {
bluetoothDevice?.connectGatt(activity, false, GattCallback(activity))
}
return true
}
@SuppressLint("MissingPermission")
private suspend fun getBluetoothDevice(bluetoothManager: BluetoothManager, address: String, isNeedDiscover: Boolean = true): BluetoothDevice? {
val adapter = bluetoothManager.adapter
if (!adapter.isEnabled) return null
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return null
if (isNeedDiscover) {
try {
if (!adapter.isDiscovering) {
adapter.startDiscovery()
delay(2000L)
//adapter.cancelDiscovery()
adapter.getRemoteDevice(address)
}else{
adapter.getRemoteDevice(address)
}
} catch (e:Exception) {
e.printStackTrace()
}
}
return adapter.getRemoteDevice(address)
}
} |
DemoFoMtu/app/src/main/java/com/au/demoformtu/IShowTextCallback.kt | 2602215615 | package com.au.demoformtu
interface IShowTextCallback {
fun onText(str:String)
} |
ctplus/src/main/kotlin/org/redsxi/bool/Bool.kt | 451293648 | package org.redsxi.bool
class Bool(private val bool: Boolean) {
companion object {
@JvmField
val TRUE = Bool(true)
@JvmField
val FALSE = Bool(false)
}
fun get(): Boolean = bool
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/mapping/Text.kt | 1187837734 | package org.redsxi.mc.ctplus.mapping
import net.minecraft.network.chat.Component
import org.redsxi.mc.ctplus.modId
object Text {
const val BLOCK = "block"
const val CARD = "card"
const val GUI = "gui"
const val TOOLTIP = "tooltip"
const val ITEM_GROUP = "itemGroup"
@JvmStatic
fun translatable(type: String, modId: String, name: String, vararg objects: Any): Component
= Component.translatable("$type.$modId.$name", *objects)
@JvmStatic
fun literal(str: String): Component
= Component.literal(str)
@JvmStatic
fun translatable(type: String, name: String, vararg objects: Any): Component
= translatable(type, modId, name, *objects)
@JvmStatic
fun empty(): Component = literal("")
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/mapping/RegistryMapper.kt | 3306639060 | package org.redsxi.mc.ctplus.mapping
import net.fabricmc.fabric.impl.itemgroup.ItemGroupHelper
import net.minecraft.core.Registry
import net.minecraft.core.registries.BuiltInRegistries
import net.minecraft.resources.ResourceLocation
import net.minecraft.world.item.CreativeModeTab
import net.minecraft.world.item.Item
import net.minecraft.world.level.block.Block
import net.minecraft.world.level.block.entity.BlockEntityType
object RegistryMapper {
private fun getBlockRegistry(): Registry<Block> = BuiltInRegistries.BLOCK
private fun getBlockEntityTypeRegistry(): Registry<BlockEntityType<*>> = BuiltInRegistries.BLOCK_ENTITY_TYPE
private fun getItemRegistry(): Registry<Item> = BuiltInRegistries.ITEM
private fun <T> register(registry: Registry<T>, location: ResourceLocation, item: T & Any): T = Registry.register(registry, location, item)
fun registerBlock(location: ResourceLocation, item: Block): Block = register(getBlockRegistry(), location, item)
fun registerBlockEntityType(location: ResourceLocation, item: BlockEntityType<*>): BlockEntityType<*> = register(
getBlockEntityTypeRegistry(), location, item)
fun registerItem(location: ResourceLocation, item: Item): Item = register(getItemRegistry(), location, item)
fun registerItemGroup(location: ResourceLocation, item: CreativeModeTab) =
ItemGroupHelper.appendItemGroup(item)
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/mapping/BarrierBlockMapper.kt | 2402693264 | package org.redsxi.mc.ctplus.mapping
import net.minecraft.core.BlockPos
import net.minecraft.server.level.ServerLevel
import net.minecraft.util.RandomSource
import net.minecraft.world.level.block.HorizontalDirectionalBlock
import net.minecraft.world.level.block.state.BlockState
import net.minecraft.world.level.material.Material
import net.minecraft.world.level.material.MaterialColor
abstract class BarrierBlockMapper : HorizontalDirectionalBlock(Properties.of(Material.METAL, MaterialColor.COLOR_GRAY).requiresCorrectToolForDrops().strength(2.0F)) {
override fun tick(
blockState: BlockState,
serverLevel: ServerLevel,
blockPos: BlockPos,
randomSource: RandomSource
) {
tick(blockState, serverLevel, blockPos)
}
open fun tick(state: BlockState, level: ServerLevel, pos: BlockPos) = Unit
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/mapping/ItemGroupMapper.kt | 1217504112 | package org.redsxi.mc.ctplus.mapping
import net.minecraft.world.item.CreativeModeTab
import net.minecraft.world.item.Item
import net.minecraft.world.item.ItemStack
import org.redsxi.mc.ctplus.mapping.Text.ITEM_GROUP
object ItemGroupMapper {
@JvmStatic
fun builder(id: String, icon: Item, items: (CreativeModeTab.Output) -> Unit): CreativeModeTab.Builder {
return CreativeModeTab.builder(CreativeModeTab.Row.TOP, 0)
.title(Text.translatable(ITEM_GROUP, id))
.icon{ItemStack(icon)}
.displayItems{_, output ->
items(output)
}
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/card/Card.kt | 3281981209 | package org.redsxi.mc.ctplus.card
import net.minecraft.network.chat.Component
import net.minecraft.resources.ResourceLocation
import net.minecraft.world.item.ItemStack
import org.redsxi.mc.ctplus.CTPlusRegistries
import org.redsxi.mc.ctplus.data.CardContext
import org.redsxi.mc.ctplus.data.CardData
import org.redsxi.mc.ctplus.idOf
import org.redsxi.mc.ctplus.item.ItemCard
import org.redsxi.mc.ctplus.mapping.Text
import org.redsxi.mc.ctplus.mapping.Text.TOOLTIP
import org.redsxi.mc.ctplus.util.MTRTranslation
@Suppress("UNCHECKED_CAST")
abstract class Card<CardDataT : CardData, CardT : Card<CardDataT, CardT>> {
private var itemOpt: ItemCard<CardT, CardDataT>? = null
val item: ItemCard<CardT, CardDataT>
get() {
return itemOpt ?: throw NullPointerException("Item of card wasn't initialized")
}
fun initItem() {
if(itemOpt != null) return
itemOpt = ItemCard(this as CardT)
}
val id: ResourceLocation get() = CTPlusRegistries.CARD.getItemID(this)
open fun getCardItemTextureLocation(): ResourceLocation = idOf("item/card/white")
fun getCardFrontTextureLocation(): ResourceLocation = idOf("item/card/white_f")
fun getCardBackTextureLocation(): ResourceLocation = idOf("item/card/white_b")
abstract fun balance(data: CardDataT): Int
open fun discountFactor(): Float = 1F
abstract fun payImpl(data: CardDataT, price: Int): Boolean
abstract fun rechargeImpl(data: CardDataT, amount: Int): Boolean
/**
* Tips 已确认是否有足够的余额/是否可预支
*/
fun pay(data: CardDataT, price: Int): Boolean {
val actualPrice = (price * discountFactor()).toInt()
return if(actualPrice <= balance(data) || (canOverdraft(data) && balance(data) >= 0)) {
payImpl(data, actualPrice)
} else false
}
fun recharge(data: CardDataT, amount: Int): Boolean {
if(canRecharge(data)) {
return rechargeImpl(data, amount)
}
return false
}
abstract fun canOverdraft(data: CardDataT): Boolean
abstract fun canRecharge(data: CardDataT): Boolean
abstract fun isValid(data: CardDataT): Boolean
open fun appendCardInformation(data: CardDataT, list: MutableList<Component>) {
if(data.isEntered) {
list.add(
Text.translatable(
TOOLTIP,
"enter_at_station",
MTRTranslation.getTranslation(data.entryStationName) as Any
)
)
}
}
override fun toString(): String {
return javaClass.simpleName
}
fun context(stack: ItemStack): CardContext<CardDataT, CardT> =
CardData.deserialize(stack)
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/card/WhiteCard.kt | 2960364933 | package org.redsxi.mc.ctplus.card
import org.redsxi.mc.ctplus.data.CardData
class WhiteCard : Card<CardData, WhiteCard>() {
override fun balance(data: CardData): Int = 0
override fun payImpl(data: CardData, price: Int): Boolean = false
override fun rechargeImpl(data: CardData, amount: Int): Boolean = false
override fun canOverdraft(data: CardData): Boolean = false
override fun canRecharge(data: CardData): Boolean = false
override fun isValid(data: CardData): Boolean = false
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/card/PrepaidCard.kt | 339665699 | package org.redsxi.mc.ctplus.card
import net.minecraft.network.chat.Component
import net.minecraft.resources.ResourceLocation
import org.redsxi.mc.ctplus.data.PrepaidCardData
import org.redsxi.mc.ctplus.idOf
import org.redsxi.mc.ctplus.mapping.Text
import org.redsxi.mc.ctplus.mapping.Text.TOOLTIP
import org.redsxi.mc.ctplus.util.Date
import org.redsxi.mc.ctplus.util.Time
class PrepaidCard : Card<PrepaidCardData, PrepaidCard>() {
/* DEPRECATED CODE 2024-3-4
private val valid: Boolean
get() {
return Time.millis < lastRechargeTime + EXPIRE_TIME
}
override fun appendCardInformation(list: MutableList<Component>) {
super.appendCardInformation(list)
list.add(Text.translatable(TOOLTIP, "card_balance", balance))
list.add(Text.translatable(TOOLTIP, "card_last_recharge_time", Date[lastRechargeTime] as Any))
if(!valid) {
list.add(Text.translatable(TOOLTIP, "card_invalid"))
}
}
*/
override fun getCardItemTextureLocation(): ResourceLocation {
return idOf("item/card/prepaid")
}
override fun isValid(data: PrepaidCardData) = Time.millis < data.lastRechargeTime + EXPIRE_TIME
override fun canRecharge(data: PrepaidCardData) = isValid(data)
override fun canOverdraft(data: PrepaidCardData) = isValid(data)
override fun rechargeImpl(data: PrepaidCardData, amount: Int): Boolean {
val b = data.balance
data.balance += amount
return b < data.balance
}
override fun payImpl(data: PrepaidCardData, price: Int): Boolean {
val b = data.balance
data.balance -= price
return b >= data.balance
}
override fun balance(data: PrepaidCardData) = data.balance
override fun appendCardInformation(data: PrepaidCardData, list: MutableList<Component>) {
super.appendCardInformation(data, list)
list.add(Text.translatable(TOOLTIP, "card_balance", data.balance))
list.add(Text.translatable(TOOLTIP, "card_last_recharge_time", Date[data.lastRechargeTime] as Any))
if(!isValid(data)) list.add(Text.translatable(TOOLTIP, "card_invalid"))
}
companion object {
const val EXPIRE_TIME: Long = 0x134FD9000
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/card/SingleJourneyCard.kt | 574419092 | package org.redsxi.mc.ctplus.card
import net.minecraft.network.chat.Component
import net.minecraft.resources.ResourceLocation
import org.redsxi.mc.ctplus.data.SingleJourneyCardData
import org.redsxi.mc.ctplus.idOf
import org.redsxi.mc.ctplus.mapping.Text
class SingleJourneyCard : Card<SingleJourneyCardData, SingleJourneyCard>() {
/*
DEPRECATED CODE AT 2024-3-3 -CTPLUS
var price: Int = 2
private var isUsed = true
override fun balance(): Int = if(isUsed) {
0
} else {
price
}
override fun payImpl(price: Int): Boolean {
if(isUsed) return false
isUsed = true
return true
}
override fun rechargeImpl(amount: Int) = false
override fun canOverdraft() = false
override fun canRecharge() = false
override fun isValid() = !isUsed
override fun getCardItemTextureLocation(): ResourceLocation {
return idOf("item/card/single_journey")
}
override fun loadData(nbt: CompoundTag) {
price = nbt.getInt("Price")
isUsed = nbt.getBoolean("IsUsed")
}
override fun saveData(nbt: CompoundTag): CompoundTag {
nbt.putInt("Price", price)
nbt.putBoolean("IsUsed", isUsed)
return nbt
}
override fun appendCardInformation(list: MutableList<Component>) {
super.appendCardInformation(list)
list.add(Text.translatable(Text.TOOLTIP, "price", price))
if(isUsed) {
list.add(Text.translatable(Text.TOOLTIP, "card_is_used"))
}
}
*/
override fun balance(data: SingleJourneyCardData): Int = if(data.isUsed) 0 else data.price
override fun payImpl(data: SingleJourneyCardData, price: Int): Boolean {
data.isUsed = true
return true
}
override fun rechargeImpl(data: SingleJourneyCardData, amount: Int): Boolean = false
override fun canOverdraft(data: SingleJourneyCardData): Boolean = false
override fun canRecharge(data: SingleJourneyCardData): Boolean = false
override fun isValid(data: SingleJourneyCardData): Boolean = !data.isUsed
override fun appendCardInformation(data: SingleJourneyCardData, list: MutableList<Component>) {
super.appendCardInformation(data, list)
list.add(Text.translatable(Text.TOOLTIP, "price", data.price))
if(data.isUsed) {
list.add(Text.translatable(Text.TOOLTIP, "card_is_used"))
}
}
override fun getCardItemTextureLocation(): ResourceLocation {
return idOf("item/card/single_journey")
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/core/PassManager.kt | 2058764905 | package org.redsxi.mc.ctplus.core
import net.minecraft.core.BlockPos
import net.minecraft.sounds.SoundEvent
import net.minecraft.sounds.SoundSource
import net.minecraft.world.entity.player.Player
import net.minecraft.world.level.Level
import net.minecraft.world.scores.Score
import net.minecraft.world.scores.criteria.ObjectiveCriteria
import org.redsxi.mc.ctplus.blockentity.BlockEntityTicketBarrierPayDirect
import org.redsxi.mc.ctplus.mapping.Text
object PassManager {
fun onEntityPass(pos: BlockPos, level: Level, player: Player, passSound: SoundEvent): Boolean {
addObjective(level)
val be = level.getBlockEntity(pos)
if(be is BlockEntityTicketBarrierPayDirect) {
val price = be.price
val balanceScore = getScore(level, player)
if(balanceScore.score < price) {
player.displayClientMessage(
Text.translatable(
Text.GUI,
"mtr",
"insufficient_balance",
balanceScore.score
), true
)
return false
}
balanceScore.add((0 - price))
player.displayClientMessage(
Text.translatable(Text.GUI, "enter_barrier", price),
true
)
level.playSound(player, pos, passSound, SoundSource.BLOCKS)
return true
}
return false
}
private fun addObjective(level: Level) {
try {
level.scoreboard.addObjective(
"mtr_balance",
ObjectiveCriteria.DUMMY,
Text.literal("\ufefa Balance 余额 \ufefa"),
ObjectiveCriteria.RenderType.INTEGER
)
} catch (_: Exception) {
}
}
private fun getScore(level: Level, player: Player): Score {
val objective = level.scoreboard.getObjective("mtr_balance") ?: throw RuntimeException("WTF")
return level.scoreboard.getOrCreatePlayerScore(player.gameProfile.name,objective)
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/core/TransitPlus.kt | 3029151641 | package org.redsxi.mc.ctplus.core
import net.minecraft.core.BlockPos
import net.minecraft.sounds.SoundEvent
import net.minecraft.sounds.SoundSource
import net.minecraft.world.entity.player.Player
import net.minecraft.world.item.ItemStack
import net.minecraft.world.level.Level
import org.redsxi.bool.Bool
import org.redsxi.mc.ctplus.blockentity.BlockEntityTicketBarrierPayDirect
import org.redsxi.mc.ctplus.card.Card
import org.redsxi.mc.ctplus.core.TransitPlus.PassType.*
import org.redsxi.mc.ctplus.data.CardContext
import org.redsxi.mc.ctplus.data.CardData
import org.redsxi.mc.ctplus.item.ItemCard
import org.redsxi.mc.ctplus.mapping.Text
import org.redsxi.mc.ctplus.mapping.Text.GUI
import org.redsxi.mc.ctplus.util.MTROptionalData
import org.redsxi.mc.ctplus.util.MTRTranslation
import kotlin.math.abs
object TransitPlus {
private const val PRICE_RADIX = 2
private fun encodeZone(zone: Int): Float = Float.fromBits(zone)
private fun decodeZone(zone: Float): Int = zone.toBits()
private fun price(entryZone: Int, exitZone: Int): Int {
return abs(entryZone - exitZone) * PRICE_RADIX
}
/*/**
* @see pass
*/
@Deprecated("Use another one")
fun pass(player: Player, price: Int, position: BlockPos, currentLevel: Level, passSound: SoundEvent): Boolean {
val itemStack = player.mainHandItem
if(itemStack == ItemStack.EMPTY) {
player.displayClientMessage(Text.translatable(GUI, "hold_card_to_pass"), true)
return false
}
val item = itemStack.item
if (item is ItemCard) {
val card = item.card
var compound = itemStack.tag
if(compound == null) {
compound = card.createData()
}
card.loadData(compound)
return if(card.isValid()) {
if(card.pay(price)) {
player.displayClientMessage(card.getPassMessage(), true)
itemStack.tag = card.createData()
currentLevel.playSound(player, position, passSound, SoundSource.BLOCKS)
true
} else {
player.displayClientMessage(Text.translatable(GUI, "insufficient_balance", card.balance()), true)
false
}
} else {
player.displayClientMessage(Text.translatable(GUI, "card_invalid"), true)
false
}
} else {
player.displayClientMessage(Text.translatable(GUI, "hold_card_to_pass"), true)
return false
}
}*/
enum class PassType {
PAY_DIRECT,
ENTRY,
EXIT
}
private fun <CDT: CardData, CT: Card<CDT, CT>> pass(cardCtx: CardContext<CDT, CT>, price: Int, player: Player, passFunc: () -> Unit): Bool =
if(cardCtx.card.pay(cardCtx.data, price)) {
player.displayClientMessage(Text.translatable(GUI, "gui.cgcem.enter_barrier", price), true)
passFunc()
Bool.TRUE
} else {
player.displayClientMessage(Text.translatable(GUI, "insufficient_balance", cardCtx.card.balance(cardCtx.data)), true)
Bool.FALSE
}
private fun <CDT: CardData, CT: Card<CDT, CT>> enter(cardCtx: CardContext<CDT, CT>, zone: Int, stationName: String, stationNameTranslated: String, player: Player, passFunc: () -> Unit): Bool {
if(cardCtx.card.balance(cardCtx.data) < 0 && !cardCtx.card.canOverdraft(cardCtx.data)) {
player.displayClientMessage(Text.translatable(GUI, "insufficient_balance", cardCtx.card.balance(cardCtx.data)), true)
return Bool.FALSE
}
if(cardCtx.data.isEntered) {
player.displayClientMessage(Text.translatable(GUI, "card_invalid"), true)
return Bool.FALSE
}
cardCtx.data.entryZoneEncoded = encodeZone(zone)
cardCtx.data.entryStationName = stationName
cardCtx.data.isEntered = true
player.displayClientMessage(Text.translatable(GUI, "entered_station", stationNameTranslated as Any, cardCtx.card.balance(cardCtx.data)), true)
passFunc()
return Bool.TRUE
}
private fun <CDT: CardData, CT: Card<CDT, CT>> exit(cardCtx: CardContext<CDT, CT>, zone: Int, stationNameTranslated: String, player: Player, passFunc: () -> Unit): Bool {
if(!cardCtx.data.isEntered) {
player.displayClientMessage(Text.translatable(GUI, "card_invalid"), true)
return Bool.FALSE
}
val price = price(decodeZone(cardCtx.data.entryZoneEncoded), zone)
return if(cardCtx.card.pay(cardCtx.data, price)) {
cardCtx.data.isEntered = false
player.displayClientMessage(Text.translatable(GUI, "exited_station", stationNameTranslated as Any, price, cardCtx.card.balance(cardCtx.data)), true)
passFunc()
Bool.TRUE
} else {
player.displayClientMessage(Text.translatable(GUI, "insufficient_balance", cardCtx.card.balance(cardCtx.data)), true)
Bool.FALSE
}
}
fun pass(player: Player, position: BlockPos, world: Level, passSound: SoundEvent, passType: PassType): Bool {
val playSoundFunc = {
world.playSound(player, position, passSound, SoundSource.BLOCKS)
}
val stack = player.mainHandItem
if (stack == ItemStack.EMPTY) {
player.displayClientMessage(Text.translatable(GUI, "hold_card_to_pass"), true)
return Bool.FALSE
}
val item = stack.item
if (item is ItemCard<*, *>) {
val card = item.card
val context = card.context(stack)
if(context.isValid()) {
val result = when (passType) {
PAY_DIRECT -> {
val bEntity = world.getBlockEntity(position)
if (bEntity is BlockEntityTicketBarrierPayDirect) {
val price = bEntity.price
pass(context, price, player, playSoundFunc)
} else Bool.FALSE // If I forgot to register the block entity
}
else -> {
val stationOptional = MTROptionalData.getStation(
MTROptionalData.getRailwayData(world),
position
)
if(!stationOptional.isPresent) {
player.displayClientMessage(Text.translatable(GUI, "barrier_not_inside_the_station"), true)
return Bool.FALSE
}
val station = stationOptional.get()
val zone = station.zone
when (passType) {
ENTRY -> {
enter(context, zone, station.name, MTRTranslation.getTranslation(station.name), player, playSoundFunc)
//Bool.FALSE
}
EXIT -> {
exit(context, zone, MTRTranslation.getTranslation(station.name), player, playSoundFunc)
//Bool.FALSE
}
else -> Bool.FALSE // Impossible but kotlin tell me to do this
}
}
}
context.update()
return result
} else {
context.update()
player.displayClientMessage(Text.translatable(GUI, "card_invalid"), true)
return Bool.FALSE
}
} else {
player.displayClientMessage(Text.translatable(GUI, "hold_card_to_pass"), true)
return Bool.FALSE
}
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/util/ResourceLocationUtil.kt | 349919946 | package org.redsxi.mc.ctplus.util
import net.minecraft.resources.ResourceLocation
object ResourceLocationUtil {
@JvmStatic
fun addPrefix(id: ResourceLocation, prefix: String) = ResourceLocation(id.namespace, "$prefix${id.path}")
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/util/Date.kt | 3714716089 | package org.redsxi.mc.ctplus.util
import java.text.SimpleDateFormat
import java.util.Date
object Date {
@JvmStatic
operator fun get(time: Long): String {
val dateFormat = SimpleDateFormat("yyyy:MM:dd HH:mm:ss")
val date = Date(time)
return dateFormat.format(date)
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/util/BlockEntityTypeUtil.kt | 2539288318 | package org.redsxi.mc.ctplus.util
import net.minecraft.core.BlockPos
import net.minecraft.world.level.block.Block
import net.minecraft.world.level.block.entity.BlockEntity
import net.minecraft.world.level.block.entity.BlockEntityType
import net.minecraft.world.level.block.state.BlockState
@SuppressWarnings("any")
object BlockEntityTypeUtil {
private fun <T : BlockEntity> create(block: Block, blockEntitySupplier: (BlockPos, BlockState) -> T): BlockEntityType<T> {
val builder = BlockEntityType.Builder.of(blockEntitySupplier, block)
return builder.build(null)
}
fun <T : BlockEntity> create(block: Block, blockEntityClass: Class<T>, vararg arguments: Any): BlockEntityType<T> {
val classArray = ArrayList<Class<out Any>>()
classArray.add(BlockPos::class.java)
classArray.add(BlockState::class.java)
arguments.forEach {
classArray.add(it::class.java)
}
val array = Array<Class<out Any>>(0) {BlockEntityTypeUtil::class.java}
val constructor = blockEntityClass.getConstructor(*classArray.toArray(array))
return create(
block
) {
pos, state -> constructor.newInstance(pos, state, *arguments)
}
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/util/MTROptionalData.kt | 1529818448 | package org.redsxi.mc.ctplus.util
import mtr.data.RailwayData
import mtr.data.Station
import net.minecraft.core.BlockPos
import net.minecraft.world.level.Level
import java.util.Optional
object MTROptionalData {
@JvmStatic
fun getRailwayData(level: Level): Optional<RailwayData> {
val data = RailwayData.getInstance(level) ?: return Optional.empty()
return Optional.of(data)
}
@JvmStatic
fun getStation(railwayData: Optional<RailwayData>, position: BlockPos): Optional<Station> {
if (!railwayData.isPresent) return Optional.empty()
val data = railwayData.get()
val station = RailwayData.getStation(data.stations, data.dataCache, position) ?: return Optional.empty()
return Optional.of(station)
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/util/FacingUtil.kt | 2875379587 | package org.redsxi.mc.ctplus.util
import net.minecraft.core.Direction
import net.minecraft.world.level.block.Block
import net.minecraft.world.phys.shapes.Shapes
import net.minecraft.world.phys.shapes.VoxelShape
object FacingUtil {
fun getVoxelShapeByDirection(
x1: Double,
y1: Double,
z1: Double,
x2: Double,
y2: Double,
z2: Double,
facing: Direction
): VoxelShape {
return when (facing) {
Direction.NORTH -> Block.box(x1, y1, z1, x2, y2, z2)
Direction.EAST -> Block.box(16.0 - z2, y1, x1, 16.0 - z1, y2, x2)
Direction.SOUTH -> Block.box(16.0 - x2, y1, 16.0 - z2, 16.0 - x1, y2, 16.0 - z1)
Direction.WEST -> Block.box(z1, y1, 16.0 - x2, z2, y2, 16.0 - x1)
else -> Shapes.block()
}
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/util/Time.kt | 2295816557 | package org.redsxi.mc.ctplus.util
interface Time {
val millis: Long
val seconds: Long
companion object : Time {
override val millis: Long
get() = System.currentTimeMillis()
override val seconds: Long
get() = millis / 1000
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/util/MTRTranslation.kt | 3667838933 | package org.redsxi.mc.ctplus.util
import net.fabricmc.api.EnvType
import net.fabricmc.api.Environment
import org.redsxi.mc.ctplus.Variables
@Environment(EnvType.CLIENT)
object MTRTranslation {
@JvmStatic
fun getTranslation(name: String): String {
val nameArray = name.split("|")
if(nameArray.size == 1) return name
return nameArray[Variables.translationIndex, 0]
}
private operator fun List<String>.get(index: Int, defaultIndex: Int): String {
if(size <= index) return this[defaultIndex]
return this[index]
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/network/SetTranslationIndexS2CPacket.kt | 3082844032 | package org.redsxi.mc.ctplus.network
import net.fabricmc.fabric.api.networking.v1.FabricPacket
import net.fabricmc.fabric.api.networking.v1.PacketType
import net.minecraft.network.FriendlyByteBuf
import org.redsxi.mc.ctplus.setTranslationIndex
class SetTranslationIndexS2CPacket(val index: Int) : FabricPacket {
constructor(buf: FriendlyByteBuf) : this(buf.readInt())
override fun write(buf: FriendlyByteBuf) {
buf.writeInt(index)
}
override fun getType(): PacketType<*> = TYPE
companion object {
@JvmField
val TYPE: PacketType<SetTranslationIndexS2CPacket> = PacketType.create(setTranslationIndex){SetTranslationIndexS2CPacket(it)}
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/blockentity/BlockEntityTicketBarrierPayDirect.kt | 1675384277 | package org.redsxi.mc.ctplus.blockentity
import net.minecraft.core.BlockPos
import net.minecraft.nbt.CompoundTag
import net.minecraft.network.protocol.Packet
import net.minecraft.network.protocol.game.ClientGamePacketListener
import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket
import net.minecraft.world.level.block.entity.BlockEntity
import net.minecraft.world.level.block.state.BlockState
import org.redsxi.bool.Bool
import org.redsxi.mc.ctplus.Collections
open class BlockEntityTicketBarrierPayDirect(pos: BlockPos, state: BlockState, isTransitPlus: Bool) : BlockEntity(
if(isTransitPlus.get()) Collections.BlockEntities.TICKET_BARRIER_PAY_DIRECT_TP else Collections.BlockEntities.TICKET_BARRIER_PAY_DIRECT,
pos, state
) {
var price: Int = 2
override fun saveAdditional(nbt: CompoundTag) {
nbt.putInt("Price", price)
super.saveAdditional(nbt)
}
override fun load(nbt: CompoundTag) {
price = nbt.getInt("Price")
super.load(nbt)
}
override fun getUpdatePacket(): Packet<ClientGamePacketListener> {
return ClientboundBlockEntityDataPacket.create(this)
}
override fun getUpdateTag(): CompoundTag {
return saveWithoutMetadata()
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/ID.kt | 415631013 | package org.redsxi.mc.ctplus
import net.minecraft.resources.ResourceLocation
const val modId: String = "ctplus"
fun idOf(name: String): ResourceLocation = ResourceLocation(modId, name)
val ticketBarrierPayDirect = idOf("ticket_barrier_pay_direct")
val card = idOf("card")
val whiteCard = idOf("white")
val singleJourneyCard = idOf("single_journey")
val prepaidCard = idOf("prepaid")
val ctPlus = idOf("ct_plus")
val ticketBarrierEntranceTp = idOf("ticket_barrier_entrance_tp")
val ticketBarrierExitTp = idOf("ticket_barrier_exit_tp")
val ticketBarrierPayDirectTp = idOf("ticket_barrier_pay_direct_tp")
val main = idOf("main")
val setTranslationIndex = idOf("set_translation_index") |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/item/ItemCard.kt | 1689302913 | package org.redsxi.mc.ctplus.item
import net.minecraft.network.chat.Component
import net.minecraft.world.item.Item
import net.minecraft.world.item.ItemStack
import net.minecraft.world.item.TooltipFlag
import net.minecraft.world.level.Level
import org.redsxi.mc.ctplus.CTPlusRegistries
import org.redsxi.mc.ctplus.card.Card
import org.redsxi.mc.ctplus.data.CardData
import org.redsxi.mc.ctplus.mapping.Text
import org.redsxi.mc.ctplus.mapping.Text.CARD
import org.redsxi.mc.ctplus.mapping.Text.TOOLTIP
class ItemCard<CardT : Card<CardDataT, CardT>, CardDataT : CardData>(val card: CardT) : Item(Properties().stacksTo(1)) {
override fun appendHoverText(
itemStack: ItemStack,
level: Level?,
list: MutableList<Component>,
tooltipFlag: TooltipFlag
) {
list.add(Text.translatable(TOOLTIP, "transit_plus_part"))
val item = itemStack.item
if(item is ItemCard<*, *>) {
val card = item.card
val context = card.context(itemStack)
list.add(Text.empty())
list.add(Text.translatable(TOOLTIP, "card_information"))
context.appendCardInformation(list)
}
}
override fun getName(itemStack: ItemStack): Component {
val id = CTPlusRegistries.CARD.getItemID(card)
return Text.translatable(CARD, id.namespace, id.path)
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/model/CardItemModelGenerator.kt | 2652541988 | package org.redsxi.mc.ctplus.model
import net.minecraft.resources.ResourceLocation
import org.slf4j.LoggerFactory
object CardItemModelGenerator {
private val LOGGER = LoggerFactory.getLogger("CardItemModelGen")
fun generate(icon: ResourceLocation): String {
val str = """
{
"parent": "item/generated",
"textures": {
"layer0": "${icon.namespace}:${icon.path}"
}
}
""".trimIndent()
LOGGER.debug("Model: $str")
return str
}
} |
ctplus/src/main/kotlin/org/redsxi/mc/ctplus/command/CommandContexts.kt | 3148703106 | package org.redsxi.mc.ctplus.command
object CommandContexts {
} |
Subsets and Splits