MyCustomScannerFragment
unknown
plain_text
2 years ago
28 kB
4
Indexable
package com.android.kepr.ui.scanner.filesRFID
import android.Manifest
import android.app.Activity
import android.bluetooth.BluetoothAdapter
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.Build
import android.os.Bundle
import android.os.Message
import android.util.Log
import android.view.Menu
import android.view.MenuItem
import android.view.View
import android.widget.AdapterView
import android.widget.ListView
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.fragment.app.Fragment
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import com.android.kepr.R
import com.android.kepr.data.db.AgentDatabase
import com.android.kepr.data.db.dao.DaoAccess
import com.android.kepr.utils.Utils
import com.uk.tsl.rfid.DeviceListActivity
import com.uk.tsl.rfid.asciiprotocol.AsciiCommander
import com.uk.tsl.rfid.asciiprotocol.BuildConfig
import com.uk.tsl.rfid.asciiprotocol.device.ConnectionState
import com.uk.tsl.rfid.asciiprotocol.device.Reader
import com.uk.tsl.rfid.asciiprotocol.device.ReaderManager
import com.uk.tsl.rfid.asciiprotocol.device.TransportType
import com.uk.tsl.rfid.asciiprotocol.enumerations.QuerySession
import com.uk.tsl.rfid.asciiprotocol.responders.LoggerResponder
import com.uk.tsl.utils.Observable
import kotlinx.android.synthetic.main.fragment_scan_via_rfid.*
class MyCustomScannerFragment : Fragment(R.layout.fragment_scan_via_rfid) {
private var myTagArraylist: ArrayList<String> = ArrayList()
private val D = BuildConfig.DEBUG
private lateinit var dao: DaoAccess
var assetsverified = 0
val totalAssets = 0
private lateinit var mGenericModelHandler: GenericHandler
private var mResultsListView: ListView? = null
private var mModel: InventoryModel? = null
private var mReader: Reader? = null
private var mLastUserDisconnectedReader: Reader? = null
private var mIsSelectingReader = false
private var requestBluetooth = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
if (result.resultCode == AppCompatActivity.RESULT_OK) {
//granted
}else{
//deny
}
}
private val requestMultiplePermissions =
registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
permissions.entries.forEach {
Log.d("test006", "${it.key} = ${it.value}")
}
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
requestMultiplePermissions.launch(arrayOf(
Manifest.permission.BLUETOOTH,
Manifest.permission.BLUETOOTH_CONNECT,Manifest.permission.BLUETOOTH_SCAN,Manifest.permission.BLUETOOTH_ADMIN,Manifest.permission.BLUETOOTH_ADVERTISE,))
}
else{
val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
requestBluetooth.launch(enableBtIntent)
}
txt_waiting_for_scan.text = "hey its working..."
mGenericModelHandler = GenericHandler(this)
dao = AgentDatabase.getInstance(activity).daoAccess()
val totalAssets = dao.getAllAssetsAccordingToCount(myTagArraylist).size
tv_assets_count.textSize = 18F
tv_assets_count.text = "$assetsverified/$totalAssets Assets verified"
iv_scanner.setOnClickListener {
}
tv_connectdevice.setOnClickListener {
mIsSelectingReader = true
var index = -1
if (mReader != null) {
index = ReaderManager.sharedInstance().readerList.list().indexOf(mReader)
}
val selectIntent: Intent = Intent(
activity,
DeviceListActivity::class.java
)
if (index >= 0) {
selectIntent.putExtra(DeviceListActivity.EXTRA_DEVICE_INDEX, index)
}
startActivityForResult(selectIntent, DeviceListActivity.SELECT_DEVICE_REQUEST)
UpdateUI()
}
AsciiCommander.createSharedInstance(requireContext())
val commander: AsciiCommander = getCommander()
commander.clearResponders()
commander.addResponder(LoggerResponder())
commander.addSynchronousResponder()
ReaderManager.create(requireContext())
// Add observers for changes
// Add observers for changes
ReaderManager.sharedInstance().readerList.readerAddedEvent().addObserver(mAddedObserver)
ReaderManager.sharedInstance().readerList.readerUpdatedEvent().addObserver(mUpdatedObserver)
ReaderManager.sharedInstance().readerList.readerRemovedEvent().addObserver(mRemovedObserver)
//Create a (custom) model and configure its commander and handler
//Create a (custom) model and configure its commander and handler
mModel = InventoryModel()
mModel!!.commander = getCommander()
mModel!!.handler = mGenericModelHandler
}
companion object {
fun newInstance(): MyCustomScannerFragment {
return MyCustomScannerFragment()
}
}
override fun onDestroy() {
super.onDestroy()
// Remove observers for changes
ReaderManager.sharedInstance().readerList.readerAddedEvent().removeObserver(mAddedObserver)
ReaderManager.sharedInstance().readerList.readerUpdatedEvent()
.removeObserver(mUpdatedObserver)
ReaderManager.sharedInstance().readerList.readerRemovedEvent()
.removeObserver(mRemovedObserver)
}
//----------------------------------------------------------------------------------------------
// Pause & Resume life cycle
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Pause & Resume life cycle
//----------------------------------------------------------------------------------------------
@Synchronized
override fun onPause() {
super.onPause()
mModel!!.setEnabled(false)
// Unregister to receive notifications from the AsciiCommander
LocalBroadcastManager.getInstance(context!!).unregisterReceiver(mCommanderMessageReceiver)
// Disconnect from the reader to allow other Apps to use it
// unless pausing when USB device attached or using the DeviceListActivity to select a Reader
if (!mIsSelectingReader && !ReaderManager.sharedInstance()
.didCauseOnPause() && mReader != null
) {
mReader!!.disconnect()
}
ReaderManager.sharedInstance().onPause()
}
@Synchronized
override fun onResume() {
super.onResume()
mModel!!.setEnabled(true)
// Register to receive notifications from the AsciiCommander
LocalBroadcastManager.getInstance(activity!!).registerReceiver(
mCommanderMessageReceiver,
IntentFilter(AsciiCommander.STATE_CHANGED_NOTIFICATION)
)
// Remember if the pause/resume was caused by ReaderManager - this will be cleared when ReaderManager.onResume() is called
val readerManagerDidCauseOnPause = ReaderManager.sharedInstance().didCauseOnPause()
// The ReaderManager needs to know about Activity lifecycle changes
ReaderManager.sharedInstance().onResume()
// The Activity may start with a reader already connected (perhaps by another App)
// Update the ReaderList which will add any unknown reader, firing events appropriately
ReaderManager.sharedInstance().updateList()
// Locate a Reader to use when necessary
AutoSelectReader(!readerManagerDidCauseOnPause)
mIsSelectingReader = false
displayReaderState()
UpdateUI()
}
//----------------------------------------------------------------------------------------------
// ReaderList Observers
//----------------------------------------------------------------------------------------------
var mAddedObserver: Observable.Observer<Reader> =
Observable.Observer { observable, reader -> // See if this newly added Reader should be used
AutoSelectReader(true)
}
var mUpdatedObserver =
Observable.Observer<Reader> { observable, reader ->
// Is this a change to the last actively disconnected reader
if (reader === mLastUserDisconnectedReader) {
// Things have changed since it was actively disconnected so
// treat it as new
mLastUserDisconnectedReader = null
}
// Was the current Reader disconnected i.e. the connected transport went away or disconnected
if (reader === mReader && !reader.isConnected) {
// No longer using this reader
mReader = null
// Stop using the old Reader
getCommander().reader = mReader
} else {
// See if this updated Reader should be used
// e.g. the Reader's USB transport connected
AutoSelectReader(true)
}
}
var mRemovedObserver =
Observable.Observer<Reader> { observable, reader ->
// Is this a change to the last actively disconnected reader
if (reader === mLastUserDisconnectedReader) {
// Things have changed since it was actively disconnected so
// treat it as new
mLastUserDisconnectedReader = null
}
// Was the current Reader removed
if (reader === mReader) {
mReader = null
// Stop using the old Reader
getCommander().reader = mReader
}
}
private fun AutoSelectReader(attemptReconnect: Boolean) {
val readerList = ReaderManager.sharedInstance().readerList
var usbReader: Reader? = null
if (readerList.list().size >= 1) {
// Currently only support a single USB connected device so we can safely take the
// first CONNECTED reader if there is one
for (reader in readerList.list()) {
if (reader.hasTransportOfType(TransportType.USB)) {
usbReader = reader
break
}
}
}
if (mReader == null) {
if (usbReader != null && usbReader !== mLastUserDisconnectedReader) {
// Use the Reader found, if any
mReader = usbReader
getCommander().reader = mReader
}
} else {
// If already connected to a Reader by anything other than USB then
// switch to the USB Reader
val activeTransport = mReader!!.activeTransport
if (activeTransport != null && activeTransport.type() != TransportType.USB && usbReader != null) {
mReader!!.disconnect()
mReader = usbReader
// Use the Reader found, if any
getCommander().reader = mReader
}
}
// Reconnect to the chosen Reader
if (mReader != null && !mReader!!.isConnecting
&& (mReader!!.activeTransport == null || mReader!!.activeTransport
.connectionStatus().value() == ConnectionState.DISCONNECTED)
) {
// Attempt to reconnect on the last used transport unless the ReaderManager is cause of OnPause (USB device connecting)
if (attemptReconnect) {
if (mReader!!.allowMultipleTransports() || mReader!!.lastTransportType == null) {
// Reader allows multiple transports or has not yet been connected so connect to it over any available transport
mReader!!.connect()
} else {
// Reader supports only a single active transport so connect to it over the transport that was last in use
mReader!!.connect(mReader!!.lastTransportType)
}
}
}
}
private var mConnectMenuItem: MenuItem? = null
private var mDisconnectMenuItem: MenuItem? = null
private var mResetMenuItem: MenuItem? = null
override fun onPrepareOptionsMenu(menu: Menu) {
val isConnecting = getCommander().connectionState == ConnectionState.CONNECTING
val isConnected = getCommander().isConnected
mDisconnectMenuItem!!.isEnabled = isConnected
mConnectMenuItem!!.isEnabled = true
mConnectMenuItem!!.title =
if (mReader != null && mReader!!.isConnected) "Change Reader" else "Change Reader"
mResetMenuItem!!.isEnabled = isConnected
super.onPrepareOptionsMenu(menu)
}
private class GenericHandler(t: MyCustomScannerFragment?) :
WeakHandler<MyCustomScannerFragment?>(t) {
override fun handleMessage(msg: Message?, t: MyCustomScannerFragment?) {
try {
when (msg?.what) {
ModelBase.BUSY_STATE_CHANGED_NOTIFICATION -> {}
ModelBase.MESSAGE_NOTIFICATION -> {
// Examine the message for prefix
val message = msg.obj as String
if (message.startsWith("ER:")) {
val value2 = message.substring(3).replaceFirst("^0+(?!$)".toRegex(), "")
Log.v("scanner that i want to edit", value2)
t?.myTagArraylist?.add(value2.toString())
} else if (message.startsWith("BC:")) {
val value2 = message.substring(3).replaceFirst("^0+(?!$)".toRegex(), "")
Log.v("scanner that i want to edit", value2)
t?.myTagArraylist?.add(value2.toString())
} else {
Log.v(
"scanner that i want to edit",
"${Utils.removefirstNchars(message, 4)}",
)
val value = message.substring(4)
val value2 = value.replaceFirst("^0+(?!$)".toRegex(), "")
Log.v("scanner that i want to edit 2", value2)
t?.myTagArraylist?.add(value2.toString())
updateUi(t?.myTagArraylist, t?.context!!, t)
}
t?.UpdateUI()
}
else -> {}
}
} catch (e: Exception) {
}
}
private fun updateUi(
myTagArraylist: ArrayList<String>?,
context: Context,
t: MyCustomScannerFragment
) {
val dao = AgentDatabase.getInstance(context).daoAccess()
t.iv_scanner.setOnClickListener { if (myTagArraylist!!.isNotEmpty()) {
Toast.makeText(t.requireActivity(), myTagArraylist.toString(), Toast.LENGTH_SHORT)
.show()
Log.v("tag", myTagArraylist.toString())
} else {
Toast.makeText(t.requireActivity(), myTagArraylist.toString(), Toast.LENGTH_SHORT)
.show()
}}
val count = dao.getAllAssetsAccordingToCount(myTagArraylist!!).size
val verified = dao.getAllAssetsAccordingToCountViaVerified(myTagArraylist,"Y").size
Log.v("crossCheck", dao.getAllAssetsAccordingToCount(myTagArraylist).toString())
t.tv_assets_count.text = "${verified}/${count} Assets verified"
}
}
private fun displayReaderState() {
var connectionMsg: String? = "Reader: "
connectionMsg += when (getCommander().connectionState) {
ConnectionState.CONNECTED -> getCommander().connectedDeviceName
ConnectionState.CONNECTING -> "Connecting..."
else -> "Disconnected"
}
txt_waiting_for_scan.text = connectionMsg
}
//
// Set the state for the UI controls
//
private fun UpdateUI() {
//boolean isConnected = getCommander().isConnected();
//TODO: configure UI control state
}
protected fun getCommander(): AsciiCommander {
return AsciiCommander.sharedInstance()
}
//
// Handle the messages broadcast from the AsciiCommander
//
private val mCommanderMessageReceiver: BroadcastReceiver = object : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
if (D) {
Log.d(
javaClass.name,
"AsciiCommander state changed - isConnected: " + getCommander().isConnected
)
}
val connectionStateMsg = intent.getStringExtra(AsciiCommander.REASON_KEY)
displayReaderState()
/* if (getCommander().isConnected) {
// Update for any change in power limits
setPowerBarLimits()
// This may have changed the current power level setting if the new range is smaller than the old range
// so update the model's inventory command for the new power value
mModel!!.command.outputPower = mPowerLevel
mModel!!.resetDevice()
mModel!!.updateConfiguration()
}*/
UpdateUI()
}
}
//----------------------------------------------------------------------------------------------
// Power seek bar
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Power seek bar
//----------------------------------------------------------------------------------------------
//
// Set the seek bar to cover the range of the currently connected device
// The power level is set to the new maximum power
//
/* private fun setPowerBarLimits() {
val deviceProperties = getCommander().deviceProperties
mPowerSeekBar!!.max =
deviceProperties.maximumCarrierPower - deviceProperties.minimumCarrierPower
mPowerLevel = deviceProperties.maximumCarrierPower
mPowerSeekBar!!.progress = mPowerLevel - deviceProperties.minimumCarrierPower
}*/
//
// Handle events from the power level seek bar. Update the mPowerLevel member variable for use in other actions
//
/*
private val mPowerSeekBarListener: SeekBar.OnSeekBarChangeListener =
object : SeekBar.OnSeekBarChangeListener {
override fun onStartTrackingTouch(seekBar: SeekBar) {
// Nothing to do here
}
override fun onStopTrackingTouch(seekBar: SeekBar) {
// Update the reader's setting only after the user has finished changing the value
updatePowerSetting(getCommander().deviceProperties.minimumCarrierPower + seekBar.progress)
mModel!!.command.outputPower = mPowerLevel
mModel!!.updateConfiguration()
}
override fun onProgressChanged(
seekBar: SeekBar, progress: Int,
fromUser: Boolean
) {
updatePowerSetting(getCommander().deviceProperties.minimumCarrierPower + progress)
}
}
*/
/* private fun updatePowerSetting(level: Int) {
mPowerLevel = level
mPowerLevelTextView!!.text = "$mPowerLevel dBm"
}
*/
//----------------------------------------------------------------------------------------------
// Button event handlers
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Button event handlers
//----------------------------------------------------------------------------------------------
// Scan (Start) action
/* private val mScanButtonListener = View.OnClickListener {
try {
mResultTextView!!.text = ""
// Start the continuous inventory
mModel!!.scanStart()
mStartButton!!.isEnabled = false
mStopButton!!.isEnabled = true
mBarcodeResultsListView!!.visibility = View.GONE
UpdateUI()
} catch (e: Exception) {
e.printStackTrace()
}
}*/
// Scan Stopaction
/* private val mScanStopButtonListener = View.OnClickListener {
try {
mResultTextView!!.text = ""
// Stop the continuous inventory
mModel!!.scanStop()
mStartButton!!.isEnabled = true
mStopButton!!.isEnabled = false
UpdateUI()
} catch (e: Exception) {
e.printStackTrace()
}
}*/
// Clear action
/*private val mClearButtonListener = View.OnClickListener {
try {
// Clear the list
mResultsArrayAdapter!!.clear()
mResultTextView!!.text = ""
mResultTextView!!.setBackgroundColor(0x00FFFFFF)
mBarcodeResultsArrayAdapter!!.clear()
mModel!!.clearUniques()
mBarcodeResultsListView!!.visibility = View.VISIBLE
UpdateUI()
} catch (e: Exception) {
e.printStackTrace()
}
}*/
//----------------------------------------------------------------------------------------------
// Handler for changes in session
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Handler for changes in session
//----------------------------------------------------------------------------------------------
private val mActionSelectedListener: AdapterView.OnItemSelectedListener =
object : AdapterView.OnItemSelectedListener {
override fun onItemSelected(parent: AdapterView<*>, view: View, pos: Int, id: Long) {
if (mModel!!.command != null) {
val targetSession = parent.getItemAtPosition(pos) as QuerySession
mModel!!.command.querySession = targetSession
mModel!!.updateConfiguration()
}
}
override fun onNothingSelected(parent: AdapterView<*>?) {}
}
//----------------------------------------------------------------------------------------------
// Handler for changes in Uniques Only
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Handler for changes in Uniques Only
//----------------------------------------------------------------------------------------------
/* private val mUniquesCheckBoxListener =
View.OnClickListener { v ->
try {
val uniquesCheckBox = v as CheckBox
mModel!!.setUniquesOnly(uniquesCheckBox.isChecked)
UpdateUI()
} catch (e: Exception) {
e.printStackTrace()
}
}*/
//----------------------------------------------------------------------------------------------
// Handler for changes in FastId
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Handler for changes in FastId
//----------------------------------------------------------------------------------------------
/* private val mFastIdCheckBoxListener =
View.OnClickListener { v ->
try {
val fastIdCheckBox = v as CheckBox
mModel!!.command.usefastId =
if (fastIdCheckBox.isChecked) TriState.YES else TriState.NO
mModel!!.updateConfiguration()
UpdateUI()
} catch (e: Exception) {
e.printStackTrace()
}
}
*/
//----------------------------------------------------------------------------------------------
// Handler for DeviceListActivity
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
// Handler for DeviceListActivity
//----------------------------------------------------------------------------------------------
//
// Handle Intent results
//
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
when (requestCode) {
DeviceListActivity.SELECT_DEVICE_REQUEST -> // When DeviceListActivity returns with a device to connect
if (resultCode == Activity.RESULT_OK) {
val readerIndex = data?.extras!!.getInt(DeviceListActivity.EXTRA_DEVICE_INDEX)
val chosenReader = ReaderManager.sharedInstance().readerList.list()[readerIndex]
val action = data.extras!!.getInt(DeviceListActivity.EXTRA_DEVICE_ACTION)
// If already connected to a different reader then disconnect it
if (mReader != null) {
if (action == DeviceListActivity.DEVICE_CHANGE || action == DeviceListActivity.DEVICE_DISCONNECT) {
mReader!!.disconnect()
if (action == DeviceListActivity.DEVICE_DISCONNECT) {
mLastUserDisconnectedReader = mReader
mReader = null
}
}
}
// Use the Reader found
if (action == DeviceListActivity.DEVICE_CHANGE || action == DeviceListActivity.DEVICE_CONNECT) {
mReader = chosenReader
mLastUserDisconnectedReader = null
getCommander().reader = mReader
}
displayReaderState()
}
}
}
/* override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
super.onActivityResult(requestCode, resultCode, data)
}*/
}Editor is loading...