888 lines
37 KiB
Java
888 lines
37 KiB
Java
package qbsg.top.ble;
|
|
public final class BleManager implements qbsg.top.ble.BleManagerFacade {
|
|
public static final int $stable = 8;
|
|
private final kotlinx.coroutines.flow.MutableStateFlow _activeDevice;
|
|
private final kotlinx.coroutines.flow.MutableStateFlow _connections;
|
|
private final kotlinx.coroutines.flow.MutableSharedFlow _disconnectEvents;
|
|
private final kotlinx.coroutines.flow.MutableStateFlow _isBluetoothEnabled;
|
|
private final kotlinx.coroutines.flow.MutableSharedFlow _messageEvents;
|
|
private final kotlinx.coroutines.flow.MutableSharedFlow _rawScanResults;
|
|
private final kotlinx.coroutines.flow.MutableStateFlow _scanState;
|
|
private final kotlinx.coroutines.flow.MutableStateFlow _scannedDevices;
|
|
private final kotlinx.coroutines.flow.MutableStateFlow _targetSessionMac;
|
|
private final kotlinx.coroutines.flow.StateFlow activeDevice;
|
|
private final android.bluetooth.BluetoothManager btManager;
|
|
private final qbsg.top.ble.BleManager$btStateReceiver$1 btStateReceiver;
|
|
private final kotlinx.coroutines.flow.StateFlow connections;
|
|
private final android.content.Context context;
|
|
private final java.util.LinkedList descriptorWriteQueue;
|
|
private final java.util.concurrent.ConcurrentHashMap deviceInfoReadJobs;
|
|
private final kotlinx.coroutines.flow.SharedFlow disconnectEvents;
|
|
private final qbsg.top.ble.BleManager$gattCallback$1 gattCallback;
|
|
private final java.util.concurrent.ConcurrentHashMap gatts;
|
|
private final String id;
|
|
private final kotlinx.coroutines.flow.StateFlow isBluetoothEnabled;
|
|
private boolean isWritingDescriptor;
|
|
private final kotlinx.coroutines.flow.SharedFlow messageEvents;
|
|
private final java.util.concurrent.ConcurrentHashMap otaChannels;
|
|
private a8.h otaManager;
|
|
private final java.util.concurrent.ConcurrentHashMap pendingCccdCount;
|
|
private final java.util.concurrent.ConcurrentHashMap pendingFirmware;
|
|
private final kotlinx.coroutines.flow.SharedFlow rawScanResults;
|
|
private final java.util.concurrent.ConcurrentHashMap readChannels;
|
|
private final qbsg.top.ble.BleManager$scanCallback$1 scanCallback;
|
|
private final kotlinx.coroutines.flow.StateFlow scanState;
|
|
private final kotlinx.coroutines.flow.StateFlow scannedDevices;
|
|
private final kotlinx.coroutines.CoroutineScope scope;
|
|
private final kotlinx.coroutines.flow.StateFlow targetSessionMac;
|
|
private final java.util.concurrent.ConcurrentHashMap$KeySetView userInitiatedDisconnections;
|
|
|
|
public BleManager(android.content.Context p5)
|
|
{
|
|
String v2_13;
|
|
kotlin.jvm.internal.s.f(p5, "context");
|
|
this.context = p5;
|
|
this.id = w7.w.i();
|
|
this.scope = kotlinx.coroutines.CoroutineScopeKt.CoroutineScope(kotlinx.coroutines.SupervisorKt.SupervisorJob$default(0, 1, 0).plus(kotlinx.coroutines.Dispatchers.getIO()));
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_9 = p5.getSystemService("bluetooth");
|
|
kotlin.jvm.internal.s.d(v0_9, "null cannot be cast to non-null type android.bluetooth.BluetoothManager");
|
|
this.btManager = ((android.bluetooth.BluetoothManager) v0_9);
|
|
this.gatts = new java.util.concurrent.ConcurrentHashMap();
|
|
this.userInitiatedDisconnections = java.util.concurrent.ConcurrentHashMap.newKeySet();
|
|
this.otaChannels = new java.util.concurrent.ConcurrentHashMap();
|
|
this.descriptorWriteQueue = new java.util.LinkedList();
|
|
this.readChannels = new java.util.concurrent.ConcurrentHashMap();
|
|
this.pendingFirmware = new java.util.concurrent.ConcurrentHashMap();
|
|
this.deviceInfoReadJobs = new java.util.concurrent.ConcurrentHashMap();
|
|
this.pendingCccdCount = new java.util.concurrent.ConcurrentHashMap();
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_28 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(q6.u.c);
|
|
this._connections = v0_28;
|
|
this.connections = kotlinx.coroutines.flow.FlowKt.asStateFlow(v0_28);
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_30 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(0);
|
|
this._activeDevice = v0_30;
|
|
this.activeDevice = kotlinx.coroutines.flow.FlowKt.asStateFlow(v0_30);
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_32 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(0);
|
|
this._targetSessionMac = v0_32;
|
|
this.targetSessionMac = kotlinx.coroutines.flow.FlowKt.asStateFlow(v0_32);
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_36 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(qbsg.top.ble.data.BleScanState.Idle);
|
|
this._scanState = v0_36;
|
|
this.scanState = kotlinx.coroutines.flow.FlowKt.asStateFlow(v0_36);
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_39 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(q6.t.c);
|
|
this._scannedDevices = v0_39;
|
|
this.scannedDevices = kotlinx.coroutines.flow.FlowKt.asStateFlow(v0_39);
|
|
String v2_10 = kotlinx.coroutines.flow.SharedFlowKt.MutableSharedFlow$default(0, 16, 0, 5, 0);
|
|
this._rawScanResults = v2_10;
|
|
this.rawScanResults = kotlinx.coroutines.flow.FlowKt.asSharedFlow(v2_10);
|
|
String v2_12 = this.getBtAdapter();
|
|
if (v2_12 == null) {
|
|
v2_13 = 0;
|
|
} else {
|
|
v2_13 = v2_12.isEnabled();
|
|
}
|
|
String v2_0 = kotlinx.coroutines.flow.StateFlowKt.MutableStateFlow(Boolean.valueOf(v2_13));
|
|
this._isBluetoothEnabled = v2_0;
|
|
this.isBluetoothEnabled = kotlinx.coroutines.flow.FlowKt.asStateFlow(v2_0);
|
|
String v2_3 = kotlinx.coroutines.flow.SharedFlowKt.MutableSharedFlow$default(0, 8, 0, 5, 0);
|
|
this._disconnectEvents = v2_3;
|
|
this.disconnectEvents = kotlinx.coroutines.flow.FlowKt.asSharedFlow(v2_3);
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_2 = kotlinx.coroutines.flow.SharedFlowKt.MutableSharedFlow$default(0, 64, 0, 5, 0);
|
|
this._messageEvents = v0_2;
|
|
this.messageEvents = kotlinx.coroutines.flow.FlowKt.asSharedFlow(v0_2);
|
|
qbsg.top.ble.BleManager$btStateReceiver$1 v0_5 = new qbsg.top.ble.BleManager$btStateReceiver$1(this);
|
|
this.btStateReceiver = v0_5;
|
|
p5.registerReceiver(v0_5, new android.content.IntentFilter("android.bluetooth.adapter.action.STATE_CHANGED"));
|
|
this.scanCallback = new qbsg.top.ble.BleManager$scanCallback$1(this);
|
|
this.gattCallback = new qbsg.top.ble.BleManager$gattCallback$1(this);
|
|
return;
|
|
}
|
|
|
|
public static synthetic boolean a(qbsg.top.ble.a p0, Object p1)
|
|
{
|
|
return qbsg.top.ble.BleManager.cleanupDevice$lambda$1(p0, p1);
|
|
}
|
|
|
|
public static final synthetic void access$cleanupDevice(qbsg.top.ble.BleManager p0, String p1, boolean p2, qbsg.top.ble.data.DisconnectReason p3)
|
|
{
|
|
p0.cleanupDevice(p1, p2, p3);
|
|
return;
|
|
}
|
|
|
|
public static final synthetic boolean access$enqueueNotify(qbsg.top.ble.BleManager p0, android.bluetooth.BluetoothGatt p1, android.bluetooth.BluetoothGattCharacteristic p2)
|
|
{
|
|
return p0.enqueueNotify(p1, p2);
|
|
}
|
|
|
|
public static final synthetic java.util.LinkedList access$getDescriptorWriteQueue$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0.descriptorWriteQueue;
|
|
}
|
|
|
|
public static final synthetic java.util.concurrent.ConcurrentHashMap access$getGatts$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0.gatts;
|
|
}
|
|
|
|
public static final synthetic java.util.concurrent.ConcurrentHashMap access$getOtaChannels$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0.otaChannels;
|
|
}
|
|
|
|
public static final synthetic java.util.concurrent.ConcurrentHashMap access$getPendingCccdCount$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0.pendingCccdCount;
|
|
}
|
|
|
|
public static final synthetic java.util.concurrent.ConcurrentHashMap access$getPendingFirmware$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0.pendingFirmware;
|
|
}
|
|
|
|
public static final synthetic java.util.concurrent.ConcurrentHashMap access$getReadChannels$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0.readChannels;
|
|
}
|
|
|
|
public static final synthetic java.util.concurrent.ConcurrentHashMap$KeySetView access$getUserInitiatedDisconnections$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0.userInitiatedDisconnections;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableStateFlow access$get_activeDevice$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._activeDevice;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableStateFlow access$get_connections$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._connections;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableSharedFlow access$get_disconnectEvents$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._disconnectEvents;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableStateFlow access$get_isBluetoothEnabled$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._isBluetoothEnabled;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableSharedFlow access$get_messageEvents$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._messageEvents;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableSharedFlow access$get_rawScanResults$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._rawScanResults;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableStateFlow access$get_scanState$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._scanState;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableStateFlow access$get_scannedDevices$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._scannedDevices;
|
|
}
|
|
|
|
public static final synthetic kotlinx.coroutines.flow.MutableStateFlow access$get_targetSessionMac$p(qbsg.top.ble.BleManager p0)
|
|
{
|
|
return p0._targetSessionMac;
|
|
}
|
|
|
|
public static final synthetic void access$processDescriptorQueue(qbsg.top.ble.BleManager p0)
|
|
{
|
|
p0.processDescriptorQueue();
|
|
return;
|
|
}
|
|
|
|
public static final synthetic Object access$readDeviceInfoString(qbsg.top.ble.BleManager p0, android.bluetooth.BluetoothGatt p1, String p2, java.util.UUID p3, kotlin.coroutines.Continuation p4)
|
|
{
|
|
return p0.readDeviceInfoString(p1, p2, p3, p4);
|
|
}
|
|
|
|
public static final synthetic void access$setWritingDescriptor$p(qbsg.top.ble.BleManager p0, boolean p1)
|
|
{
|
|
p0.isWritingDescriptor = p1;
|
|
return;
|
|
}
|
|
|
|
public static final synthetic void access$startDeviceInfoRead(qbsg.top.ble.BleManager p0, android.bluetooth.BluetoothGatt p1)
|
|
{
|
|
p0.startDeviceInfoRead(p1);
|
|
return;
|
|
}
|
|
|
|
public static final synthetic void access$updateDeviceInfo(qbsg.top.ble.BleManager p0, String p1, String p2)
|
|
{
|
|
p0.updateDeviceInfo(p1, p2);
|
|
return;
|
|
}
|
|
|
|
public static synthetic boolean b(String p0, qbsg.top.ble.BleManager$DescriptorWriteRequest p1)
|
|
{
|
|
return qbsg.top.ble.BleManager.cleanupDevice$lambda$0(p0, p1);
|
|
}
|
|
|
|
private final void checkPrerequisitesOrThrow()
|
|
{
|
|
qbsg.top.ble.data.BleException$BluetoothDisabled v0_1;
|
|
if (android.os.Build$VERSION.SDK_INT < 31) {
|
|
v0_1 = k3.t.K("android.permission.ACCESS_FINE_LOCATION");
|
|
} else {
|
|
v0_1 = q6.n.Y(new String[] {"android.permission.BLUETOOTH_SCAN", "android.permission.BLUETOOTH_CONNECT"}));
|
|
}
|
|
java.util.ArrayList v1_2 = new java.util.ArrayList();
|
|
qbsg.top.ble.data.BleException$BluetoothDisabled v0_2 = v0_1.iterator();
|
|
while (v0_2.hasNext()) {
|
|
Object v2_1 = v0_2.next();
|
|
if (this.context.checkSelfPermission(((String) v2_1)) != 0) {
|
|
v1_2.add(v2_1);
|
|
}
|
|
}
|
|
if (!v1_2.isEmpty()) {
|
|
throw new qbsg.top.ble.data.BleException$PermissionDenied(v1_2);
|
|
} else {
|
|
if (!this.getBtAdapter().isEnabled()) {
|
|
throw new qbsg.top.ble.data.BleException$BluetoothDisabled();
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private final void cleanupDevice(String p7, boolean p8, qbsg.top.ble.data.DisconnectReason p9)
|
|
{
|
|
this.userInitiatedDisconnections.remove(p7);
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_24 = ((kotlinx.coroutines.Job) this.deviceInfoReadJobs.remove(p7));
|
|
String v2 = 0;
|
|
if (v0_24 != null) {
|
|
kotlinx.coroutines.Job$DefaultImpls.cancel$default(v0_24, 0, 1, 0);
|
|
}
|
|
this.pendingFirmware.remove(p7);
|
|
this.pendingCccdCount.remove(p7);
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_12 = ((kotlinx.coroutines.channels.Channel) this.readChannels.remove(p7));
|
|
if (v0_12 != null) {
|
|
kotlinx.coroutines.channels.SendChannel$DefaultImpls.close$default(v0_12, 0, 1, 0);
|
|
}
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_16 = ((android.bluetooth.BluetoothGatt) this.gatts.get(p7));
|
|
if (v0_16 != null) {
|
|
v0_16.close();
|
|
}
|
|
this.gatts.remove(p7);
|
|
this.descriptorWriteQueue.removeIf(new qbsg.top.ble.b(new qbsg.top.ble.a(p7)));
|
|
if (this.descriptorWriteQueue.isEmpty()) {
|
|
this.isWritingDescriptor = 0;
|
|
}
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_23 = this._connections;
|
|
do {
|
|
int v3_3 = v0_23.getValue();
|
|
java.util.Map v4_3 = ((java.util.Map) v3_3);
|
|
kotlin.jvm.internal.s.f(v4_3, "<this>");
|
|
java.util.Map v4_4 = q6.y.c0(v4_3);
|
|
v4_4.remove(p7);
|
|
int v5_1 = v4_4.size();
|
|
if (v5_1 == 0) {
|
|
v4_4 = q6.u.c;
|
|
} else {
|
|
if (v5_1 == 1) {
|
|
v4_4 = q6.y.d0(v4_4);
|
|
}
|
|
}
|
|
} while(!v0_23.compareAndSet(v3_3, v4_4));
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_28;
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_27 = ((qbsg.top.ble.data.BleDeviceInfo) this._activeDevice.getValue());
|
|
if (v0_27 == null) {
|
|
v0_28 = 0;
|
|
} else {
|
|
v0_28 = v0_27.getAddress();
|
|
}
|
|
if (kotlin.jvm.internal.s.b(v0_28, p7)) {
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_35 = ((Iterable) ((java.util.Map) this._connections.getValue()).values()).iterator();
|
|
while (v0_35.hasNext()) {
|
|
kotlinx.coroutines.flow.MutableStateFlow v1_7 = v0_35.next();
|
|
if ((((qbsg.top.ble.data.BleConnectionInfo) v1_7).getState() instanceof qbsg.top.ble.data.DeviceConnectionState$Connected)) {
|
|
}
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_36;
|
|
kotlinx.coroutines.flow.MutableStateFlow v1_8 = ((qbsg.top.ble.data.BleConnectionInfo) v1_7);
|
|
if (v1_8 == null) {
|
|
v0_36 = 0;
|
|
} else {
|
|
v0_36 = v1_8.getDevice();
|
|
}
|
|
int v3_0;
|
|
kotlinx.coroutines.flow.MutableStateFlow v1_9 = this._targetSessionMac;
|
|
if (v0_36 == null) {
|
|
v3_0 = 0;
|
|
} else {
|
|
v3_0 = v0_36.getAddress();
|
|
}
|
|
v1_9.setValue(v3_0);
|
|
this._activeDevice.setValue(v0_36);
|
|
}
|
|
v1_7 = 0;
|
|
}
|
|
if (kotlin.jvm.internal.s.b(this._targetSessionMac.getValue(), p7)) {
|
|
int v7_7 = ((Iterable) ((java.util.Map) this._connections.getValue()).values()).iterator();
|
|
while (v7_7.hasNext()) {
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_6 = v7_7.next();
|
|
if ((((qbsg.top.ble.data.BleConnectionInfo) v0_6).getState() instanceof qbsg.top.ble.data.DeviceConnectionState$Connected)) {
|
|
}
|
|
int v7_8;
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_7 = ((qbsg.top.ble.data.BleConnectionInfo) v0_6);
|
|
if (v0_7 == null) {
|
|
v7_8 = 0;
|
|
} else {
|
|
v7_8 = v0_7.getDevice();
|
|
}
|
|
kotlinx.coroutines.flow.MutableStateFlow v0_8 = this._targetSessionMac;
|
|
if (v7_8 != 0) {
|
|
v2 = v7_8.getAddress();
|
|
}
|
|
v0_8.setValue(v2);
|
|
this._activeDevice.setValue(v7_8);
|
|
}
|
|
v0_6 = 0;
|
|
}
|
|
if ((p8) && (p9 != null)) {
|
|
this._disconnectEvents.tryEmit(p9);
|
|
}
|
|
return;
|
|
}
|
|
|
|
public static synthetic void cleanupDevice$default(qbsg.top.ble.BleManager p0, String p1, boolean p2, qbsg.top.ble.data.DisconnectReason p3, int p4, Object p5)
|
|
{
|
|
if ((p4 & 2) != 0) {
|
|
p2 = 0;
|
|
}
|
|
if ((p4 & 4) != 0) {
|
|
p3 = 0;
|
|
}
|
|
p0.cleanupDevice(p1, p2, p3);
|
|
return;
|
|
}
|
|
|
|
private static final boolean cleanupDevice$lambda$0(String p0, qbsg.top.ble.BleManager$DescriptorWriteRequest p1)
|
|
{
|
|
return kotlin.jvm.internal.s.b(p1.getGatt().getDevice().getAddress(), p0);
|
|
}
|
|
|
|
private static final boolean cleanupDevice$lambda$1(a7.c p0, Object p1)
|
|
{
|
|
return ((Boolean) p0.invoke(p1)).booleanValue();
|
|
}
|
|
|
|
private final boolean enqueueNotify(android.bluetooth.BluetoothGatt p5, android.bluetooth.BluetoothGattCharacteristic p6)
|
|
{
|
|
p5.setCharacteristicNotification(p6, 1);
|
|
android.bluetooth.BluetoothGattDescriptor v1_1 = p6.getDescriptor(qbsg.top.ble.BleManagerKt.access$getCCCD_UUID$p());
|
|
if (v1_1 != null) {
|
|
byte[] v6_1;
|
|
if ((p6.getProperties() & 32) == 0) {
|
|
v6_1 = android.bluetooth.BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE;
|
|
} else {
|
|
v6_1 = android.bluetooth.BluetoothGattDescriptor.ENABLE_INDICATION_VALUE;
|
|
}
|
|
java.util.LinkedList v2 = this.descriptorWriteQueue;
|
|
kotlin.jvm.internal.s.c(v6_1);
|
|
v2.add(new qbsg.top.ble.BleManager$DescriptorWriteRequest(p5, v1_1, v6_1));
|
|
this.processDescriptorQueue();
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private final android.bluetooth.BluetoothAdapter getBtAdapter()
|
|
{
|
|
return this.btManager.getAdapter();
|
|
}
|
|
|
|
private final void processDescriptorQueue()
|
|
{
|
|
if ((!this.isWritingDescriptor) && (!this.descriptorWriteQueue.isEmpty())) {
|
|
java.util.LinkedList v0_9 = ((qbsg.top.ble.BleManager$DescriptorWriteRequest) this.descriptorWriteQueue.peek());
|
|
if (v0_9 != null) {
|
|
int v1_0 = 1;
|
|
this.isWritingDescriptor = 1;
|
|
if (android.os.Build$VERSION.SDK_INT < 33) {
|
|
v0_9.getDesc().setValue(v0_9.getValue());
|
|
v1_0 = v0_9.getGatt().writeDescriptor(v0_9.getDesc());
|
|
} else {
|
|
if (b.b.b(v0_9.getGatt(), v0_9.getDesc(), v0_9.getValue()) != 0) {
|
|
v1_0 = 0;
|
|
}
|
|
}
|
|
if (v1_0 == 0) {
|
|
this.descriptorWriteQueue.poll();
|
|
this.isWritingDescriptor = 0;
|
|
this.processDescriptorQueue();
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
private final Object readDeviceInfoString(android.bluetooth.BluetoothGatt p12, String p13, java.util.UUID p14, kotlin.coroutines.Continuation p15)
|
|
{
|
|
qbsg.top.ble.BleManager$readDeviceInfoString$1 v0_2;
|
|
if (!(p15 instanceof qbsg.top.ble.BleManager$readDeviceInfoString$1)) {
|
|
v0_2 = new qbsg.top.ble.BleManager$readDeviceInfoString$1(this, p15);
|
|
} else {
|
|
v0_2 = ((qbsg.top.ble.BleManager$readDeviceInfoString$1) p15);
|
|
Object v1_2 = ((qbsg.top.ble.BleManager$readDeviceInfoString$1) p15).label;
|
|
if ((v1_2 & -2147483648) == 0) {
|
|
} else {
|
|
((qbsg.top.ble.BleManager$readDeviceInfoString$1) p15).label = (v1_2 - -2147483648);
|
|
}
|
|
}
|
|
Object v12_16;
|
|
android.bluetooth.BluetoothGattCharacteristic v8_1;
|
|
Object v15_6;
|
|
Object v13_10;
|
|
int v14_2;
|
|
long v6_3;
|
|
Object v15_1 = v0_2.result;
|
|
Object v1_1 = kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED();
|
|
qbsg.top.ble.BleManager$readDeviceInfoString$result$1 v2_3 = v0_2.label;
|
|
int v4 = 1;
|
|
if (v2_3 == null) {
|
|
q6.y.Y(v15_1);
|
|
Object v15_3 = p12.getServices();
|
|
kotlin.jvm.internal.s.e(v15_3, "getServices(...)");
|
|
qbsg.top.ble.BleManager$readDeviceInfoString$result$1 v2_6 = new java.util.ArrayList();
|
|
Object v15_4 = v15_3.iterator();
|
|
while (v15_4.hasNext()) {
|
|
long v6_6 = ((android.bluetooth.BluetoothGattService) v15_4.next()).getCharacteristics();
|
|
kotlin.jvm.internal.s.e(v6_6, "getCharacteristics(...)");
|
|
q6.o.f0(v2_6, v6_6);
|
|
}
|
|
Object v15_5 = v2_6.size();
|
|
v6_3 = 0;
|
|
j7.d v7_0 = 0;
|
|
while (v7_0 < v15_5) {
|
|
android.bluetooth.BluetoothGattCharacteristic v8_0 = v2_6.get(v7_0);
|
|
v7_0++;
|
|
if (kotlin.jvm.internal.s.b(((android.bluetooth.BluetoothGattCharacteristic) v8_0).getUuid(), p14)) {
|
|
}
|
|
v8_1 = ((android.bluetooth.BluetoothGattCharacteristic) v8_0);
|
|
if (v8_1 != null) {
|
|
v15_6 = p14;
|
|
v14_2 = p13;
|
|
v13_10 = p12;
|
|
v12_16 = 0;
|
|
if (v12_16 >= 3) {
|
|
v4 = v6_3;
|
|
if (v4 != 0) {
|
|
Object v12_3 = ((kotlinx.coroutines.channels.Channel) this.readChannels.get(v14_2));
|
|
if (v12_3 != null) {
|
|
long v6_1 = j7.h.m(4, j7.d.f);
|
|
qbsg.top.ble.BleManager$readDeviceInfoString$result$1 v2_2 = new qbsg.top.ble.BleManager$readDeviceInfoString$result$1(v12_3, v15_6, 0);
|
|
v0_2.L$0 = kotlin.coroutines.jvm.internal.SpillingKt.nullOutSpilledVariable(v13_10);
|
|
v0_2.L$1 = kotlin.coroutines.jvm.internal.SpillingKt.nullOutSpilledVariable(v14_2);
|
|
v0_2.L$2 = kotlin.coroutines.jvm.internal.SpillingKt.nullOutSpilledVariable(v15_6);
|
|
v0_2.L$3 = kotlin.coroutines.jvm.internal.SpillingKt.nullOutSpilledVariable(v8_1);
|
|
v0_2.L$4 = kotlin.coroutines.jvm.internal.SpillingKt.nullOutSpilledVariable(v12_3);
|
|
v0_2.I$0 = v4;
|
|
v0_2.label = 2;
|
|
v15_1 = kotlinx.coroutines.TimeoutKt.withTimeoutOrNull-KLykuaI(v6_1, v2_2, v0_2);
|
|
if (v15_1 != v1_1) {
|
|
Object v15_2 = ((p6.g) v15_1);
|
|
if (v15_2 != null) {
|
|
Object v12_13 = ((byte[]) v15_2.d);
|
|
if (v12_13.length != 0) {
|
|
Object v12_15 = i7.i.S0(new String(v12_13, i7.a.a)).toString();
|
|
if (v12_15.length() != 0) {
|
|
return v12_15;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (!v13_10.readCharacteristic(v8_1)) {
|
|
long v9_4 = j7.h.m(120, j7.d.e);
|
|
v0_2.L$0 = v13_10;
|
|
v0_2.L$1 = v14_2;
|
|
v0_2.L$2 = v15_6;
|
|
v0_2.L$3 = v8_1;
|
|
v0_2.I$0 = v6_3;
|
|
v0_2.I$1 = v12_16;
|
|
v0_2.label = 1;
|
|
if (kotlinx.coroutines.DelayKt.delay-VtjQ1oo(v9_4, v0_2) == v1_1) {
|
|
}
|
|
}
|
|
}
|
|
return v1_1;
|
|
}
|
|
}
|
|
v8_0 = 0;
|
|
} else {
|
|
if (v2_3 == 1) {
|
|
v12_16 = v0_2.I$1;
|
|
Object v13_11 = v0_2.I$0;
|
|
int v14_4 = ((android.bluetooth.BluetoothGattCharacteristic) v0_2.L$3);
|
|
qbsg.top.ble.BleManager$readDeviceInfoString$result$1 v2_9 = ((java.util.UUID) v0_2.L$2);
|
|
long v6_8 = ((String) v0_2.L$1);
|
|
j7.d v7_3 = ((android.bluetooth.BluetoothGatt) v0_2.L$0);
|
|
q6.y.Y(v15_1);
|
|
v8_1 = v14_4;
|
|
v15_6 = v2_9;
|
|
v14_2 = v6_8;
|
|
v6_3 = v13_11;
|
|
v13_10 = v7_3;
|
|
do {
|
|
v12_16++;
|
|
} while(v4 != 0);
|
|
} else {
|
|
if (v2_3 != 2) {
|
|
throw new IllegalStateException("call to \'resume\' before \'invoke\' with coroutine");
|
|
} else {
|
|
p12 = ((android.bluetooth.BluetoothGattCharacteristic) v0_2.L$3);
|
|
p12 = ((String) v0_2.L$1);
|
|
q6.y.Y(v15_1);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private final void startDeviceInfoRead(android.bluetooth.BluetoothGatt p9)
|
|
{
|
|
String v0_1 = p9.getDevice().getAddress();
|
|
java.util.concurrent.ConcurrentHashMap v1_4 = ((kotlinx.coroutines.Job) this.deviceInfoReadJobs.get(v0_1));
|
|
if ((v1_4 == null) || (v1_4.isActive() != 1)) {
|
|
this.deviceInfoReadJobs.put(v0_1, kotlinx.coroutines.BuildersKt.launch$default(this.scope, 0, 0, new qbsg.top.ble.BleManager$startDeviceInfoRead$1(this, v0_1, p9, 0), 3, 0));
|
|
return;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
private final void updateDeviceInfo(String p20, String p21)
|
|
{
|
|
kotlinx.coroutines.flow.MutableStateFlow v2 = this._connections;
|
|
do {
|
|
boolean v3_0 = v2.getValue();
|
|
java.util.Map v4_1 = ((java.util.Map) v3_0);
|
|
qbsg.top.ble.data.BleConnectionInfo v5_2 = ((qbsg.top.ble.data.BleConnectionInfo) v4_1.get(p20));
|
|
if (v5_2 != null) {
|
|
int v7_0;
|
|
if (p21 != null) {
|
|
v7_0 = p21;
|
|
} else {
|
|
v7_0 = "\u672a\u77e5";
|
|
}
|
|
String v13;
|
|
if (!v7_0.equals("\u672a\u77e5")) {
|
|
v13 = v7_0;
|
|
} else {
|
|
v13 = 0;
|
|
}
|
|
int v7_4;
|
|
p6.g v6_2 = qbsg.top.ble.data.BleDeviceInfo.copy$default(v5_2.getDevice(), 0, 0, 0, v13, 0, 0, 0, 119, 0);
|
|
int v7_3 = ((qbsg.top.ble.data.BleDeviceInfo) this._activeDevice.getValue());
|
|
if (v7_3 == 0) {
|
|
v7_4 = 0;
|
|
} else {
|
|
v7_4 = v7_3.getAddress();
|
|
}
|
|
if (kotlin.jvm.internal.s.b(v7_4, p20)) {
|
|
this._activeDevice.setValue(v6_2);
|
|
}
|
|
v4_1 = q6.y.L(v4_1, new p6.g(p20, qbsg.top.ble.data.BleConnectionInfo.copy$default(v5_2, v6_2, 0, 2, 0)));
|
|
}
|
|
} while(!v2.compareAndSet(v3_0, v4_1));
|
|
return;
|
|
}
|
|
|
|
public void closeOtaChannel(String p2)
|
|
{
|
|
kotlin.jvm.internal.s.f(p2, "address");
|
|
this.otaChannels.remove(p2);
|
|
return;
|
|
}
|
|
|
|
public void connect(qbsg.top.ble.data.BleDeviceInfo p7)
|
|
{
|
|
kotlin.jvm.internal.s.f(p7, "device");
|
|
this.checkPrerequisitesOrThrow();
|
|
if (!this.gatts.containsKey(p7.getAddress())) {
|
|
android.bluetooth.BluetoothGatt v0_6 = this._connections;
|
|
do {
|
|
java.util.concurrent.ConcurrentHashMap v1_0 = v0_6.getValue();
|
|
} while(!v0_6.compareAndSet(v1_0, q6.y.L(((java.util.Map) v1_0), new p6.g(p7.getAddress(), new qbsg.top.ble.data.BleConnectionInfo(p7, qbsg.top.ble.data.DeviceConnectionState$Connecting.INSTANCE)))));
|
|
this.gatts.put(p7.getAddress(), this.getBtAdapter().getRemoteDevice(p7.getAddress()).connectGatt(this.context, 0, this.gattCallback, 2));
|
|
return;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void destroy()
|
|
{
|
|
try {
|
|
this.context.unregisterReceiver(this.btStateReceiver);
|
|
} catch (Exception) {
|
|
}
|
|
java.util.Iterator v0_4 = this.gatts.keySet();
|
|
kotlin.jvm.internal.s.e(v0_4, "<get-keys>(...)");
|
|
java.util.Iterator v0_2 = q6.o.G0(((Iterable) v0_4)).iterator();
|
|
}
|
|
|
|
public void disconnect(String p9)
|
|
{
|
|
kotlin.jvm.internal.s.f(p9, "address");
|
|
android.bluetooth.BluetoothGatt v0_3 = ((android.bluetooth.BluetoothGatt) this.gatts.get(p9));
|
|
if (v0_3 != null) {
|
|
boolean v1_3;
|
|
boolean v1_2 = ((qbsg.top.ble.data.BleConnectionInfo) ((java.util.Map) this._connections.getValue()).get(p9));
|
|
if (!v1_2) {
|
|
v1_3 = 0;
|
|
} else {
|
|
v1_3 = v1_2.getState();
|
|
}
|
|
if (!(v1_3 instanceof qbsg.top.ble.data.DeviceConnectionState$Connecting)) {
|
|
this.userInitiatedDisconnections.add(p9);
|
|
v0_3.disconnect();
|
|
return;
|
|
} else {
|
|
qbsg.top.ble.BleManager.cleanupDevice$default(this, p9, 0, 0, 4, 0);
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.StateFlow getActiveDevice()
|
|
{
|
|
return this.activeDevice;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.StateFlow getConnections()
|
|
{
|
|
return this.connections;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.SharedFlow getDisconnectEvents()
|
|
{
|
|
return this.disconnectEvents;
|
|
}
|
|
|
|
public String getId()
|
|
{
|
|
return this.id;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.SharedFlow getMessageEvents()
|
|
{
|
|
return this.messageEvents;
|
|
}
|
|
|
|
public a8.h getOtaManager()
|
|
{
|
|
return this.otaManager;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.SharedFlow getRawScanResults()
|
|
{
|
|
return this.rawScanResults;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.StateFlow getScanState()
|
|
{
|
|
return this.scanState;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.StateFlow getScannedDevices()
|
|
{
|
|
return this.scannedDevices;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.StateFlow getTargetSessionMac()
|
|
{
|
|
return this.targetSessionMac;
|
|
}
|
|
|
|
public kotlinx.coroutines.flow.StateFlow isBluetoothEnabled()
|
|
{
|
|
return this.isBluetoothEnabled;
|
|
}
|
|
|
|
public qbsg.top.ble.GattOtaChannel openOtaChannel(String p3)
|
|
{
|
|
kotlin.jvm.internal.s.f(p3, "address");
|
|
java.util.concurrent.ConcurrentHashMap v0_3 = ((android.bluetooth.BluetoothGatt) this.gatts.get(p3));
|
|
if (v0_3 != null) {
|
|
qbsg.top.ble.BleManager$AndroidGattOtaChannel v1_1 = new qbsg.top.ble.BleManager$AndroidGattOtaChannel(this, v0_3);
|
|
this.otaChannels.put(p3, v1_1);
|
|
return v1_1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public void setActiveFocus(qbsg.top.ble.data.BleDeviceInfo p3)
|
|
{
|
|
kotlin.jvm.internal.s.f(p3, "device");
|
|
qbsg.top.ble.data.BleDeviceInfo v0_1 = ((qbsg.top.ble.data.BleConnectionInfo) ((java.util.Map) this._connections.getValue()).get(p3.getAddress()));
|
|
if ((v0_1 != null) && ((v0_1.getState() instanceof qbsg.top.ble.data.DeviceConnectionState$Connected))) {
|
|
this._targetSessionMac.setValue(p3.getAddress());
|
|
this._activeDevice.setValue(v0_1.getDevice());
|
|
}
|
|
return;
|
|
}
|
|
|
|
public boolean setBluetoothEnabled(boolean p2)
|
|
{
|
|
throw new p6.f("An operation is not implemented: Not yet implemented");
|
|
}
|
|
|
|
public void setOtaManager(a8.h p1)
|
|
{
|
|
this.otaManager = p1;
|
|
return;
|
|
}
|
|
|
|
public void startScan()
|
|
{
|
|
this.checkPrerequisitesOrThrow();
|
|
int v1_1 = qbsg.top.ble.data.BleScanState.Scanning;
|
|
if (this._scanState.getValue() != v1_1) {
|
|
this._scannedDevices.setValue(q6.t.c);
|
|
this._scanState.setValue(v1_1);
|
|
android.bluetooth.le.BluetoothLeScanner v0_2 = this.getBtAdapter().getBluetoothLeScanner();
|
|
if (v0_2 != null) {
|
|
v0_2.startScan(0, new android.bluetooth.le.ScanSettings$Builder().setScanMode(2).build(), this.scanCallback);
|
|
}
|
|
kotlinx.coroutines.BuildersKt.launch$default(this.scope, 0, 0, new qbsg.top.ble.BleManager$startScan$1(this, 0), 3, 0);
|
|
return;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void stopScan()
|
|
{
|
|
if (this._scanState.getValue() == qbsg.top.ble.data.BleScanState.Scanning) {
|
|
try {
|
|
android.bluetooth.le.BluetoothLeScanner v0_5 = this.getBtAdapter();
|
|
} catch (Exception) {
|
|
this._scanState.setValue(qbsg.top.ble.data.BleScanState.Idle);
|
|
return;
|
|
}
|
|
if ((v0_5 == null) || (v0_5.isEnabled() != 1)) {
|
|
this._scanState.setValue(qbsg.top.ble.data.BleScanState.Idle);
|
|
return;
|
|
} else {
|
|
android.bluetooth.le.BluetoothLeScanner v0_2 = this.getBtAdapter().getBluetoothLeScanner();
|
|
if (v0_2 == null) {
|
|
this._scanState.setValue(qbsg.top.ble.data.BleScanState.Idle);
|
|
return;
|
|
} else {
|
|
v0_2.stopScan(this.scanCallback);
|
|
this._scanState.setValue(qbsg.top.ble.data.BleScanState.Idle);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
public void updateDeviceType(String p17, w7.y p18)
|
|
{
|
|
kotlin.jvm.internal.s.f(p17, "address");
|
|
kotlinx.coroutines.flow.MutableStateFlow v2_1 = this._connections;
|
|
do {
|
|
boolean v3_1 = v2_1.getValue();
|
|
java.util.Map v4_0 = ((java.util.Map) v3_1);
|
|
qbsg.top.ble.data.BleConnectionInfo v5_1 = ((qbsg.top.ble.data.BleConnectionInfo) v4_0.get(p17));
|
|
if (v5_1 != null) {
|
|
int v7_4;
|
|
p6.g v6_1 = qbsg.top.ble.data.BleDeviceInfo.copy$default(v5_1.getDevice(), 0, 0, 0, 0, 0, p18, 0, 95, 0);
|
|
int v7_3 = ((qbsg.top.ble.data.BleDeviceInfo) this._activeDevice.getValue());
|
|
if (v7_3 == 0) {
|
|
v7_4 = 0;
|
|
} else {
|
|
v7_4 = v7_3.getAddress();
|
|
}
|
|
if (kotlin.jvm.internal.s.b(v7_4, p17)) {
|
|
this._activeDevice.setValue(v6_1);
|
|
}
|
|
v4_0 = q6.y.L(v4_0, new p6.g(p17, qbsg.top.ble.data.BleConnectionInfo.copy$default(v5_1, v6_1, 0, 2, 0)));
|
|
}
|
|
} while(!v2_1.compareAndSet(v3_1, v4_0));
|
|
return;
|
|
}
|
|
|
|
public void updateScreenSize(String p17, String p18)
|
|
{
|
|
kotlin.jvm.internal.s.f(p17, "address");
|
|
String v8 = p18;
|
|
kotlin.jvm.internal.s.f(p18, "screenSize");
|
|
kotlinx.coroutines.flow.MutableStateFlow v2_2 = this._connections;
|
|
while(true) {
|
|
Object v13 = v2_2.getValue();
|
|
java.util.Map v14_1 = ((java.util.Map) v13);
|
|
qbsg.top.ble.data.BleConnectionInfo v15_1 = ((qbsg.top.ble.data.BleConnectionInfo) v14_1.get(p17));
|
|
if (v15_1 != null) {
|
|
p6.g v4_4;
|
|
qbsg.top.ble.data.BleConnectionInfo v3_2 = qbsg.top.ble.data.BleDeviceInfo.copy$default(v15_1.getDevice(), 0, 0, 0, 0, v8, 0, 0, 111, 0);
|
|
p6.g v4_3 = ((qbsg.top.ble.data.BleDeviceInfo) this._activeDevice.getValue());
|
|
if (v4_3 == null) {
|
|
v4_4 = 0;
|
|
} else {
|
|
v4_4 = v4_3.getAddress();
|
|
}
|
|
if (kotlin.jvm.internal.s.b(v4_4, p17)) {
|
|
this._activeDevice.setValue(v3_2);
|
|
}
|
|
v14_1 = q6.y.L(v14_1, new p6.g(p17, qbsg.top.ble.data.BleConnectionInfo.copy$default(v15_1, v3_2, 0, 2, 0)));
|
|
}
|
|
if (v2_2.compareAndSet(v13, v14_1)) {
|
|
break;
|
|
}
|
|
v8 = p18;
|
|
}
|
|
return;
|
|
}
|
|
|
|
public void updateSelectPhase(String p17, w7.x p18)
|
|
{
|
|
kotlin.jvm.internal.s.f(p17, "address");
|
|
w7.x v10 = p18;
|
|
kotlin.jvm.internal.s.f(p18, "phase");
|
|
kotlinx.coroutines.flow.MutableStateFlow v2_2 = this._connections;
|
|
while(true) {
|
|
Object v13 = v2_2.getValue();
|
|
java.util.Map v14_1 = ((java.util.Map) v13);
|
|
qbsg.top.ble.data.BleConnectionInfo v15_1 = ((qbsg.top.ble.data.BleConnectionInfo) v14_1.get(p17));
|
|
if (v15_1 != null) {
|
|
p6.g v4_4;
|
|
qbsg.top.ble.data.BleConnectionInfo v3_2 = qbsg.top.ble.data.BleDeviceInfo.copy$default(v15_1.getDevice(), 0, 0, 0, 0, 0, 0, v10, 63, 0);
|
|
p6.g v4_3 = ((qbsg.top.ble.data.BleDeviceInfo) this._activeDevice.getValue());
|
|
if (v4_3 == null) {
|
|
v4_4 = 0;
|
|
} else {
|
|
v4_4 = v4_3.getAddress();
|
|
}
|
|
if (kotlin.jvm.internal.s.b(v4_4, p17)) {
|
|
this._activeDevice.setValue(v3_2);
|
|
}
|
|
v14_1 = q6.y.L(v14_1, new p6.g(p17, qbsg.top.ble.data.BleConnectionInfo.copy$default(v15_1, v3_2, 0, 2, 0)));
|
|
}
|
|
if (v2_2.compareAndSet(v13, v14_1)) {
|
|
break;
|
|
}
|
|
v10 = p18;
|
|
}
|
|
return;
|
|
}
|
|
}
|