Android Can'；工作完成后，不要停止worker（ListenableWorker）任务

我似乎找不到正确的方法来停止我的工作任务。我正在调用

.set（Result.success（））ResolvableFuture

上执行code>，但它从未在我的类中触发

onStopped（）

，并且其他订阅的回调似乎仍在我的工作进程中处于活动状态

• 我的工作人员启动并尝试查找特定的设备
• 它连接到该设备并尝试退出，结果为

  Result.success（）

• 如果工作进程已运行超过3分钟，则尝试退出

调用

Result.success（）

后，在我连接到BLE设备后，它仍会在

connectionstatechange

内部

connectGatt（）

函数中保留对

onConnectionStateChange

的活动引用

即使在操作系统强制停止我的工作程序后，它似乎也不会调用

onStopped（）

，因为我不记得在日志中见过它

即使创建了一个新的worker，我仍然会在旧worker中使用

onConnectionStateChange

package test;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanFilter;
import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanSettings;
import android.content.Context;
import android.os.Build;
import android.os.Handler;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.concurrent.futures.ResolvableFuture;
import androidx.work.ListenableWorker;
import androidx.work.WorkerParameters;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.List;

import static android.bluetooth.BluetoothDevice.TRANSPORT_LE;
import static android.os.Build.VERSION_CODES.M;

public class BluetoothScanWorker extends ListenableWorker  {

    private String TAG = "BluetoothScanWorker";
    private BluetoothAdapter bluetoothAdapter;
    private ResolvableFuture<Result> mFuture;


    public BluetoothScanWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    @NonNull
    @Override
    public ListenableFuture<Result> startWork() {
        mFuture = ResolvableFuture.create();

        Log.d(TAG ,"startWork()");

        if (Build.VERSION.SDK_INT >= M) {
            ScanSettings settings = (new ScanSettings.Builder().setScanMode(ScanSettings.SCAN_MODE_LOW_POWER)).build();
            List<ScanFilter> filters_v2 = new ArrayList<>();
            ScanFilter scanFilter = new ScanFilter.Builder()
                    .setDeviceAddress("B8:27:EB:B9:5C:FC")
                    .build();
            filters_v2.add(scanFilter);
            BluetoothManager bluetoothManager =
                    (BluetoothManager) this.getApplicationContext().getSystemService(Context.BLUETOOTH_SERVICE);
            bluetoothAdapter = bluetoothManager.getAdapter();
            bluetoothAdapter.getBluetoothLeScanner().startScan(filters_v2, settings, leScanCallback); // Scan for every BLE device matching my filter

            Handler handler = new Handler();
            handler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    endWork();
                }
            }, 3*60*1000); // End worker after 3 minutes
        }
        return mFuture;
    }


    private void endWork(){
        if (Build.VERSION.SDK_INT >= M) {
            Log.d(TAG, "END WORK");
            bluetoothAdapter.getBluetoothLeScanner().stopScan(leScanCallback);
            mFuture.set(Result.success());
        }
    }


    @RequiresApi(M)
    private ScanCallback leScanCallback = new ScanCallback() { // Called when I find my BLE device
        @Override
        public void onScanResult(int callbackType, ScanResult result) {
            Log.d(TAG ,"onScanResult: " + result.getDevice().toString());
            bluetoothAdapter.getBluetoothLeScanner().stopScan(this);
            result.getDevice().connectGatt(getApplicationContext(), true, new BluetoothGattCallback() { // Connect to my BLE device
                @Override
                public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
                    if (newState == BluetoothProfile.STATE_CONNECTED) {
                        if (status == BluetoothGatt.GATT_SUCCESS) {
                            Log.d(TAG ,"GATT connected successfully");
                            endWork();
                        }
                    } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                        Log.d(TAG ,"GATT disconnected");
                        endWork();
                    }

                }
            },TRANSPORT_LE);

        }
    };


    @Override
    public void onStopped() {
        Log.d(TAG, "Work service stopped");
    }

}

封装测试；
导入android.bluetooth.BluetoothAdapter；
导入android.bluetooth.BluetoothGatt；
导入android.bluetooth.BluetoothGattCallback；
导入android.bluetooth.BluetoothManager；
导入android.bluetooth.BluetoothProfile；
导入android.bluetooth.le.ScanCallback；
导入android.bluetooth.le.ScanFilter；
导入android.bluetooth.le.ScanResult；
导入android.bluetooth.le.ScanSettings；
导入android.content.Context；
导入android.os.Build；
导入android.os.Handler；
导入android.util.Log；
导入androidx.annotation.NonNull；
导入androidx.annotation.RequiresApi；
导入androidx.concurrent.futures.ResolvableFuture；
导入androidx.work.ListenableWorker；
导入androidx.work.worker参数；
导入com.google.common.util.concurrent.ListenableFuture；
导入java.util.ArrayList；
导入java.util.List；
导入静态android.bluetooth.BluetoothDevice.TRANSPORT\u LE；
导入静态android.os.Build.VERSION\u CODES.M；
公共类BluetoothScanWorker扩展ListenableWorker{
私有字符串TAG=“BluetoothScanWorker”；
私人蓝牙适配器；
私人可决议的未来；
公共BluetoothScanWorker（@NonNull上下文，@NonNull WorkerParameters workerParams）{
超级（上下文、工作参数）；
}
@非空
@凌驾
可公开上市的未来startWork（）{
mFuture=ResolvableFuture.create（）；
Log.d（标记“startWork（）”）；
如果（Build.VERSION.SDK_INT>=M）{
ScanSettings settings=（新建ScanSettings.Builder（）.setScanMode（ScanSettings.SCAN_MODE_LOW_POWER））.build（）；
列表筛选器_v2=new ArrayList（）；
ScanFilter ScanFilter=new ScanFilter.Builder（）
.setDeviceAddress（“B8:27:EB:B9:5C:FC”）
.build（）；
过滤器2.添加（扫描过滤器）；
蓝牙管理器蓝牙管理器=
（BluetoothManager）this.getApplicationContext（）.getSystemService（Context.BLUETOOTH_服务）；
bluetoothAdapter=bluetoothManager.getAdapter（）；
bluetoothAdapter.getBluetoothLeScanner（）.startScan（过滤器_v2，设置，leScanCallback）；//扫描与我的过滤器匹配的每个BLE设备
Handler=newhandler（）；
handler.postDelayed（新的Runnable（）{
@凌驾
公开募捐{
收尾工作（）；
}
}，3*60*1000）；//3分钟后结束工作
}
回归未来；
}
私人工程（）{
如果（Build.VERSION.SDK_INT>=M）{
日志d（标签“结束工作”）；
bluetoothAdapter.getBluetoothLeScanner（）.stopScan（leScanCallback）；
mFuture.set（Result.success（））；
}
}
@要求API（M）
private ScanCallback leScanCallback=new ScanCallback（）{//在我找到我的可扩展设备时调用
@凌驾
公共void onScanResult（int callbackType、ScanResult）{
Log.d（标记“onScanResult:+result.getDevice（）.toString（））；
bluetoothAdapter.getBluetoothLeScanner（）.stopScan（此）；
result.getDevice（）.connectGatt（getApplicationContext（），true，新的BluetoothGattCallback（）{//连接到我的BLE设备
@凌驾
连接状态更改的公共无效（蓝牙gatt gatt、int状态、int新闻状态）{
if（newState==BluetoothProfile.STATE\u CONNECTED）{
如果（状态==蓝牙GATT.GATT\U成功）{
Log.d（标记“GATT连接成功”）；
收尾工作（）；
}
}else if（newState==BluetoothProfile.STATE\u已断开连接）{
日志d（标签“GATT断开”）；
收尾工作（）；
}
}
}，运输署）；
}
};
@凌驾
公共空间{
日志d（标签“工作服务已停止”）；
}
}

注意，

ListenableWorker.onStopped（）

方法仅在工人被取消或任务被系统抢占时调用。如果工作进程已成功完成，则不会调用

onStop（）

。

onStop（）

：

当此工作者被告知停止时，将调用此方法。。。 这可能是由于用户发出明确的取消信号， 或者是因为系统决定抢先完成任务

---

有时，即使工作进程成功完成，也可以调用

onStop（）

回调，但这将在将来得到修复。看看这篇帖子：

那么，返回成功或失败的结果并不会告诉工人它已经完成了，应该停止了？那么，我如何停止当前正在运行的任务（而不取消重复工作的下一个任务）。@somerandomusername当您从

startWork返回成功或失败结果时(