doWork()
类中实现Worker
,可以轻松地安排同步工作,但如果我想在后台进行一些异步工作呢?例如,我想使用Retrofit进行网络服务调用。我知道我可以发出同步网络请求,但它会阻塞线程并且感觉不对。有没有解决方案,或者目前还不支持?
答案 0 :(得分:20)
我使用了countdownlatch并等待它达到0,这只会在异步回调更新后才会发生。看到这段代码:
public WorkerResult doWork() {
final WorkerResult[] result = {WorkerResult.RETRY};
CountDownLatch countDownLatch = new CountDownLatch(1);
FirebaseFirestore db = FirebaseFirestore.getInstance();
db.collection("collection").whereEqualTo("this","that").get().addOnCompleteListener(task -> {
if(task.isSuccessful()) {
task.getResult().getDocuments().get(0).getReference().update("field", "value")
.addOnCompleteListener(task2 -> {
if (task2.isSuccessful()) {
result[0] = WorkerResult.SUCCESS;
} else {
result[0] = WorkerResult.RETRY;
}
countDownLatch.countDown();
});
} else {
result[0] = WorkerResult.RETRY;
countDownLatch.countDown();
}
});
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
return result[0];
}
答案 1 :(得分:12)
仅供参考,现在有ListenableWorker,它被设计为异步的。
编辑:以下是一些示例用法摘要。我删去了我认为没有说明性的大量代码,因此很有可能在这里出现一两个小错误。
这是一项任务,该任务需要一个字符串photoKey,从服务器检索元数据,执行一些压缩工作,然后上载压缩的照片。这发生在主线程之外。这是我们发送工作请求的方式:
private void compressAndUploadFile(final String photoKey) {
Data inputData = new Data.Builder()
.putString(UploadWorker.ARG_PHOTO_KEY, photoKey)
.build();
Constraints constraints = new Constraints.Builder()
.setRequiredNetworkType(NetworkType.CONNECTED)
.build();
OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(UploadWorker.class)
.setInputData(inputData)
.setConstraints(constraints)
.build();
WorkManager.getInstance().enqueue(request);
}
在UploadWorker中:
public class UploadWorker extends ListenableWorker {
private static final String TAG = "UploadWorker";
public static final String ARG_PHOTO_KEY = "photo-key";
private String mPhotoKey;
/**
* @param appContext The application {@link Context}
* @param workerParams Parameters to setup the internal state of this worker
*/
public UploadWorker(@NonNull Context appContext, @NonNull WorkerParameters workerParams) {
super(appContext, workerParams);
mPhotoKey = workerParams.getInputData().getString(ARG_PHOTO_KEY);
}
@NonNull
@Override
public ListenableFuture<Payload> onStartWork() {
SettableFuture<Payload> future = SettableFuture.create();
Photo photo = getPhotoMetadataFromServer(mPhotoKey).addOnCompleteListener(task -> {
if (!task.isSuccessful()) {
Log.e(TAG, "Failed to retrieve photo metadata", task.getException());
future.setException(task.getException());
return;
}
MyPhotoType photo = task.getResult();
File file = photo.getFile();
Log.d(TAG, "Compressing " + photo);
MyImageUtil.compressImage(file, MyConstants.photoUploadConfig).addOnCompleteListener(compressionTask -> {
if (!compressionTask.isSuccessful()) {
Log.e(TAG, "Could not parse " + photo + " as an image.", compressionTask.getException());
future.set(new Payload(Result.FAILURE));
return;
}
byte[] imageData = compressionTask.getResult();
Log.d(TAG, "Done compressing " + photo);
UploadUtil.uploadToServer(photo, imageData);
future.set(new Payload(Result.SUCCESS));
});
});
return future;
}
}
答案 2 :(得分:9)
默认情况下,WorkManager在后台线程上运行其操作。如果您已经在后台线程上运行并且需要对WorkManager进行同步(阻塞)调用,请使用synchronous()来访问此类方法。
因此,如果您不使用result := Struct{}
,则可以安全地从$ php -S 0.0.0.0:8000
执行同步网络呼叫。从设计角度来看,这也是一种更好的方法,因为回调很混乱。
那就是说,如果你真的想要从synchronous()
激活异步作业,你需要暂停执行线程并在使用doWork()
机制(或其他一些机制)完成异步作业时恢复它线程管理机制,例如doWork()
)。在大多数情况下,我不建议这样做。
作为旁注,WorkManager处于非常早期的alpha。
答案 3 :(得分:6)
如果您正在谈论asynchronus工作,您可以将您的工作转移到RxJava Observables / Singles。
有一组运营商,例如.blockingGet()
或.blockingFirst()
它将Observable<T>
转换为阻止T
Worker
在后台线程上执行,因此请不要担心NetworkOnMainThreadException
。
答案 4 :(得分:1)
我使用了BlockingQueue
,它简化了同步线程和传递结果的过程,您只需要一个对象
private var disposable = Disposables.disposed()
override fun doWork(): Result {
val result = LinkedBlockingQueue<Result>()
disposable = completable.subscribe(
{ result.put(Result.SUCCESS) },
{ result.put(Result.RETRY) }
)
return try {
result.take()
} catch (e: InterruptedException) {
Result.RETRY
}
}
如果您的工作程序已停止,也不要忘记释放资源,这是与.blockingGet()
相比的主要优势,因为现在您可以正确地自由取消Rx任务了。
override fun onStopped(cancelled: Boolean) {
disposable.dispose()
}
答案 5 :(得分:0)
借助协程的强大功能,您可以像这样“同步” doWork()
:
用于异步获取位置的挂起方法:
private suspend fun getLocation(): Location = suspendCoroutine { continuation ->
val mFusedLocationClient = LocationServices.getFusedLocationProviderClient(appContext)
mFusedLocationClient.lastLocation.addOnSuccessListener {
continuation.resume(it)
}.addOnFailureListener {
continuation.resumeWithException(it)
}
}
在doWork()
中的通话示例:
override fun doWork(): Result {
val loc = runBlocking {
getLocation()
}
val latitude = loc.latitude
}
答案 6 :(得分:0)
我也希望使用@TomH建议的方法。我当时在Firebase Storage中使用了它。与CountDownlatch一起使用WorkManager可以帮到我。这里是一个代码片段。日志使用Timber完成。
在任务完成后但在工作人员返回成功之前,它将作为字符串从Firebase返回downloadUrl。
@NonNull
@Override
public Result doWork() {
mFirebaseStorage = mFirebaseStorage.getInstance();
mTriviaImageStorageReference = mFirebaseStorage.getReference().child("images");
CountDownLatch countDown = new CountDownLatch(2);
Uri imageUri = Uri.parse(getInputData().getString(KEY_IMAGE_URI));
try {
// get the image reference
final StorageReference imageRef = mTriviaImageStorageReference.child(imageUri.getLastPathSegment());
// upload the image to Firebase
imageRef.putFile(imageUri).continueWithTask(new Continuation<UploadTask.TaskSnapshot, Task<Uri>>() {
@Override
public Task<Uri> then(@NonNull Task<UploadTask.TaskSnapshot> task) throws Exception {
if (!task.isSuccessful()) {
throw task.getException();
}
countDown.countDown();
return imageRef.getDownloadUrl();
}
}).addOnCompleteListener(new OnCompleteListener<Uri>() {
@Override
public void onComplete(@NonNull Task<Uri> task) {
if (task.isSuccessful()) {
Timber.d("Image was successfully uploaded to Firebase");
Uri downloadUri = task.getResult();
String imageUrl = downloadUri.toString();
Timber.d(("URl of the image is: " + imageUrl));
mOutputData = new Data.Builder()
.putString(KEY_FIREBASE_IMAGE_URL, imageUrl)
.build();
countDown.countDown();
} else {
Toast.makeText(getApplicationContext(), "upload failed", Toast.LENGTH_SHORT).show();
countDown.countDown();
}
}
});
countDown.await();
return Result.success(mOutputData);
} catch (Throwable throwable) {
Timber.e(throwable, "Error uploading image");
return Result.failure();
}
}
答案 7 :(得分:0)
这很晚了,但这可能会帮助其他人,
您可以使用CoroutineWorker
并在doWork()中使用名为suspendCancellableCoroutine
的东西,它为此目的而专门设计。
下面是代码段:
class FileDownloader(private val appContext: Context, params: WorkerParameters) :
CoroutineWorker(appContext, params) {
override suspend fun doWork(): Result {
try {
suspendCancellableCoroutine<Int> { cancellableContinuation ->
// Here you can call your asynchronous callback based network
override fun onComplete() {
cancellableContinuation.resumeWith(
kotlin.Result.success(100))
}
override fun onError(error: Error?) {
cancellableContinuation.resumeWithException(
error?.connectionException ?: Throwable()
)
}
}
}catch (e: Exception) {
return Result.failure()
}
return Result.success()
}
}
在这里,协程将停止,直到您调用cancellableContinuation.resumeWith。