mir/kdeconnect-android
2
0
Fork 0
mirror of https://github.com/KDE/kdeconnect-android synced 2025-08-22 09:58:08 +00:00
Code Issues Releases Wiki Activity

Migrate NsdResolveQueue to Kotlin

Browse Source
This commit is contained in:
TPJ Schikhof 2024-09-15 08:07:31 +00:00 committed by Philip Cohn-Cort
parent 9f788da478
commit 2f10f1d0f2
2 changed files with 66 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
src/org/kde/kdeconnect/Backends/LanBackend/NsdResolveQueue.java
View File

@ -1,91 +0,0 @@
/*
* SPDX-FileCopyrightText: 2023 Albert Vaca Cintora <albertvaka@gmail.com>
*
* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/
package org.kde.kdeconnect.Backends.LanBackend;
import android.net.nsd.NsdManager;
import android.net.nsd.NsdServiceInfo;
import android.util.Log;
import androidx.annotation.NonNull;
import java.util.LinkedList;
public class NsdResolveQueue {
static final String LOG_TAG = "NsdResolveQueue";
final @NonNull NsdManager mNsdManager;
private final Object mLock = new Object();
private final LinkedList<PendingResolve> mResolveRequests = new LinkedList<>();
public NsdResolveQueue(NsdManager nsdManager) {
this.mNsdManager = nsdManager;
}
private static class PendingResolve {
final @NonNull NsdServiceInfo serviceInfo;
final @NonNull NsdManager.ResolveListener listener;
private PendingResolve(@NonNull NsdServiceInfo serviceInfo, @NonNull NsdManager.ResolveListener listener) {
this.serviceInfo = serviceInfo;
this.listener = listener;
}
}
public void resolveOrEnqueue(@NonNull NsdServiceInfo serviceInfo, @NonNull NsdManager.ResolveListener listener) {
synchronized (mLock) {
for (PendingResolve existing : mResolveRequests) {
if (serviceInfo.getServiceName().equals(existing.serviceInfo.getServiceName())) {
Log.i(LOG_TAG, "Not enqueuing a new resolve request for the same service: " + serviceInfo.getServiceName());
return;
}
}
mResolveRequests.addLast(new PendingResolve(serviceInfo, new ListenerWrapper(listener)));
if (mResolveRequests.size() == 1) {
resolveNextRequest();
}
}
}
private class ListenerWrapper implements NsdManager.ResolveListener {
private final @NonNull NsdManager.ResolveListener mListener;
private ListenerWrapper(@NonNull NsdManager.ResolveListener listener) {
mListener = listener;
}
@Override
public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
mListener.onResolveFailed(serviceInfo, errorCode);
synchronized (mLock) {
mResolveRequests.pop();
resolveNextRequest();
}
}
@Override
public void onServiceResolved(NsdServiceInfo serviceInfo) {
mListener.onServiceResolved(serviceInfo);
synchronized (mLock) {
mResolveRequests.pop();
resolveNextRequest();
}
}
}
private void resolveNextRequest() {
if (!mResolveRequests.isEmpty()) {
PendingResolve request = mResolveRequests.getFirst();
mNsdManager.resolveService(request.serviceInfo, request.listener);
}
}
}

66
src/org/kde/kdeconnect/Backends/LanBackend/NsdResolveQueue.kt Normal file
View File

@ -0,0 +1,66 @@
/*
* SPDX-FileCopyrightText: 2023 Albert Vaca Cintora <albertvaka@gmail.com>
*
* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
*/
package org.kde.kdeconnect.Backends.LanBackend
import android.net.nsd.NsdManager
import android.net.nsd.NsdServiceInfo
import android.util.Log
import java.util.LinkedList
class NsdResolveQueue {
val LOG_TAG: String = "NsdResolveQueue"
private val nsdManager: NsdManager
private val lock: Any
private data class PendingResolve(val serviceInfo: NsdServiceInfo, val listener: NsdManager.ResolveListener)
private val resolveRequests: LinkedList<PendingResolve>
constructor(nsdManager: NsdManager) {
this.nsdManager = nsdManager
this.lock = Any()
this.resolveRequests = LinkedList<PendingResolve>()
}
fun resolveOrEnqueue(serviceInfo: NsdServiceInfo, listener: NsdManager.ResolveListener) {
synchronized(lock) {
if (resolveRequests.any { r -> serviceInfo.serviceName == r.serviceInfo.serviceName }) {
Log.i(LOG_TAG, "Not enqueuing a new resolve request for the same service: " + serviceInfo.serviceName)
return
}
resolveRequests.addLast(PendingResolve(serviceInfo, ListenerWrapper(listener)))
if (resolveRequests.size == 1) {
resolveNextRequest()
}
}
}
private inner class ListenerWrapper(private val listener: NsdManager.ResolveListener) : NsdManager.ResolveListener {
override fun onResolveFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {
listener.onResolveFailed(serviceInfo, errorCode)
postResolve()
}
override fun onServiceResolved(serviceInfo: NsdServiceInfo) {
listener.onServiceResolved(serviceInfo)
postResolve()
}
private fun postResolve() {
synchronized(lock) {
resolveRequests.pop()
resolveNextRequest()
}
}
}
private fun resolveNextRequest() {
if (resolveRequests.isNotEmpty()) {
val request = resolveRequests.first
nsdManager.resolveService(request.serviceInfo, request.listener)
}
}
}