Java Android WorkManager返回多个结果

我对

WorkManager

（对Java还是新手）相当陌生，似乎有一些问题。 基本上，我们有一个应用程序，用户可以上传一些记录到服务器上

让他们上传不是问题。但是，我们希望能够在网络断开连接的情况下继续上传。在做了一些研究之后，我偶然发现了

WorkManager

。在观看了多个视频和一些教程之后，我们决定试一试

我让它工作（有点），但我有一个问题，它返回多个结果，而不是一个。 我想做的是让它在所有记录更新后返回一次结果（成功或失败），然后使用

AlertDialog

显示它是否成功。 我认为它为工作请求中的每个数据项返回一个结果，而不是只返回一次。 但我不知道为什么，甚至不知道如何修复它。 当我运行它3时，

AlertDialogs

将出现，前2个没有正确的信息，但最后一个有

分项数字： 单击上载按钮时，我调用一个

UpLoadBatchRecords

方法。

UploadBatchRecords

方法设置工作请求的数据、约束和排队：

public void UploadBatchRecords() {
        BatchMaster batchMaster = batchList.get(curBatchPosition);
        final Data data = new Data.Builder()
                .putInt(String.valueOf(NetworkConnected.CUR_POSITION), curBatchPosition)
                .putString(NetworkConnected.currentModule, batchMaster.ModuleName)
                .putString(NetworkConnected.currentBatch, batchMaster.BatchID)
                .build();

        Constraints constraints = new Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .build();


        final OneTimeWorkRequest workRequest = new OneTimeWorkRequest.Builder(NetworkConnected.class)
                .setInputData(data)
                .setConstraints(constraints)
                .build();

        WorkManager.getInstance().enqueue(workRequest);

        WorkManager.getInstance().getWorkInfoByIdLiveData(workRequest.getId())
                   .observe(this, new Observer<WorkInfo>() {
                               @Override
                               public void onChanged(WorkInfo workInfo) {
                                   if (workInfo.getState().isFinished() && workInfo.getState() == WorkInfo.State.SUCCEEDED) {
                                       message = workInfo.getOutputData().getString(NetworkConnected.KEY_SUCCESS);
                                   }
                                   else {
                                       message = workInfo.getOutputData().getString(NetworkConnected.KEY_FAILURE);
                                   }

                                   alert(message);
                               }
                           });
    }

public void UploadBatchRecords（）{
BatchMaster BatchMaster=batchList.get（位置）；
最终数据=新数据.Builder（）
.putInt（String.valueOf（NetworkConnected.CUR_位置），curBatchPosition）
.putString（NetworkConnected.currentModule、batchMaster.ModuleName）
.putString（NetworkConnected.currentBatch、batchMaster.BatchID）
.build（）；
约束=新约束。生成器（）
.setRequiredNetworkType（NetworkType.CONNECTED）
.build（）；
最终OneTimeWorkRequest workRequest=新的OneTimeWorkRequest.Builder（NetworkConnected.class）
.setInputData（数据）
.setConstraints（约束）
.build（）；
WorkManager.getInstance（）.enqueue（workRequest）；
WorkManager.getInstance（）.GetWorkInfoByIdleData（workRequest.getId（））
.观察（这个，新的观察者）{
@凌驾
更改后的公共无效（WorkInfo WorkInfo）{
if（workInfo.getState（）.isFinished（）&&workInfo.getState（）==workInfo.State.successed）{
message=workInfo.getOutputData（）.getString（NetworkConnected.KEY\u成功）；
}
否则{
message=workInfo.getOutputData（）.getString（NetworkConnected.KEY\u失败）；
}
警报（信息）；
}
});
}

工人阶级：

public class NetworkConnected extends Worker {
    public NetworkConnected(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    private ArrayList<BatchMaster> batchList;
    public static final int CUR_POSITION = 0;
    public static final String currentModule = "Module Name";
    public static final String currentBatch = "Batch ID";
    public static final String KEY_SUCCESS = "Success";
    public static final String KEY_FAILURE = "Failure";

        @NonNull
    @Override
    public Result doWork() {
            int curPosition = getInputData().getInt(String.valueOf(CUR_POSITION), 0);
            String moduleName = getInputData().getString(currentModule);
            String batchID = getInputData().getString(currentBatch);
            LoadBatches();

            try {

                UploadBatchRecords(curPosition, moduleName, batchID);

                Data success = new Data.Builder()
                        .putString(KEY_SUCCESS, " records have been updated \n\n")
                        .build();

                return Result.success(success);
            }
            catch (Exception e) {
                Data failure = new Data.Builder()
                        .putString(KEY_FAILURE, " records failed to upload")
                        .build();
                return Result.failure(failure);
            }
        }

    public void UploadBatchRecords(Integer curPosition, String modName, String batchID) {
        int seqNum;
        String recordData;

        Cursor cur = Global.dbManager.fetchBatchRecords(companyID, modName, batchID);
        while (cur.moveToNext()) {
            seqNum = cur.getInt(cur.getColumnIndex("SequenceNumber"));
            recordData = cur.getString(cur.getColumnIndex("RecordData"));

            BatchRecordWebService(curPosition, seqNum, recordData);
        }
        cur.close();
    }

    public void BatchRecordWebService(Integer position, Integer seqNum, String recordData) {
        BatchMaster batchMaster = batchList.get(position);

        final WebService webservice = new WebService();

        webservice.setMethodName("UploadRecord");
        ArrayList<PropertyInfo> props = new ArrayList<>();
        AddWebServiceProperty(props, "CompanyID", companyID, String.class);
        AddWebServiceProperty(props, "ModuleName", batchMaster.ModuleName, String.class);
        AddWebServiceProperty(props, "BatchID", batchMaster.BatchID, String.class);
        AddWebServiceProperty(props, "SequenceNumber", seqNum.toString(), String.class);
        AddWebServiceProperty(props, "RecordData", recordData, String.class);
        AddWebServiceProperty(props, "CreatedBy", batchMaster.CreatedBy, String.class);
        AddWebServiceProperty(props, "CreatedDate", batchMaster.CreatedDate, String.class);
        AddWebServiceProperty(props, "UploadedBy", batchMaster.UpdatedBy, String.class);
        AddWebServiceProperty(props, "UploadDate", batchMaster.UpdatedDate, String.class);

        webservice.setSoapProperties(props);

        try {
            webservice.execute().get();

            if (webservice.getSuccess()) {
                Global.count++;
            }
            else{
                Global.failedCount++;
            }
        } catch (Exception ignored) {
        }
    }

    public void LoadBatches() {
        batchList = new ArrayList<>();

        Cursor cur = Global.dbManager.fetchBatches();
        while (cur.moveToNext()) {
            BatchMaster view = new BatchMaster(cur.getString(cur.getColumnIndex("ModuleName")),
                    cur.getString(cur.getColumnIndex("BatchID")),
                    cur.getString(cur.getColumnIndex("FormatName")),
                    cur.getInt(cur.getColumnIndex("RecordCount")),
                    cur.getString(cur.getColumnIndex("CreatedBy")),
                    cur.getString(cur.getColumnIndex("CreateDate")),
                    cur.getString(cur.getColumnIndex("UpdatedBy")),
                    cur.getString(cur.getColumnIndex("UpdateDate")));
            batchList.add(view);
        }
        cur.close();
   }

公共类网络连接扩展工作程序{
公共网络连接（@NonNull上下文，@NonNull WorkerParameters workerParams）{
超级（上下文、工作参数）；
}
私有ArrayList批处理列表；
公共静态最终int CUR_位置=0；
公共静态最终字符串currentModule=“模块名称”；
公共静态最终字符串currentBatch=“批次ID”；
公共静态最终字符串键\u SUCCESS=“SUCCESS”；
公共静态最终字符串键\u FAILURE=“FAILURE”；
@非空
@凌驾
公共成果工作（）{
int curPosition=getInputData（）；
String moduleName=getInputData（）.getString（currentModule）；
String batchID=getInputData（）.getString（currentBatch）；
LoadBatches（）；
试一试{
UploadBatchRecords（curPosition、moduleName、batchID）；
数据成功=新建数据.Builder（）
.putString（键\u SUCCESS，“记录已更新\n\n”）
.build（）；
返回结果。成功（success）；
}
捕获（例外e）{
数据失败=新建数据.Builder（）
.putString（按键失败，“记录上传失败”）
.build（）；
返回结果。失败（失败）；
}
}
public void UploadBatchRecords（整数curPosition、字符串modName、字符串batchID）{
int-seqNum；
字符串记录数据；
Cursor cur=Global.dbManager.fetchBatchRecords（companyID、modName、batchID）；
while（cur.moveToNext（））{
seqNum=cur.getInt（cur.getColumnIndex（“SequenceNumber”）；
recordData=cur.getString（cur.getColumnIndex（“recordData”）；
BatchRecordWebService（curPosition、seqNum、recordData）；
}
cur.close（）；
}
public void BatchRecordWebService（整数位置、整数seqNum、字符串recordData）{
BatchMaster BatchMaster=batchList.get（位置）；
最终WebService WebService=新WebService（）；
setMethodName（“UploadRecord”）；
ArrayList props=新的ArrayList（）；
AddWebServiceProperty（props，“CompanyID”，CompanyID，String.class）；
AddWebServiceProperty（props，“ModuleName”、batchMaster.ModuleName、String.class）；
AddWebServiceProperty（props，“BatchID”、batchMaster.BatchID、String.class）；
AddWebServiceProperty（props，“SequenceNumber”，seqNum.toString（），String.class）；
AddWebServiceProperty（props，“RecordData”，RecordData，String.class）；
AddWebServiceProperty（props，“CreatedBy”，batchMaster.CreatedBy，String.class）；
AddWebServiceProperty（props，“CreatedDate”，batchMaster.CreatedDate，String.class）；
AddWebServiceProperty（props，“UploadedBy”，batchMaster.UpdatedBy，String.class）；
AddWebServiceProperty（道具，“上载日期”，b
else {
  message = workInfo.getOutputData().getString(NetworkConnected.KEY_FAILURE);
                                       alert(message);
                                   }

                               }
                           });

else if (workInfo.getState() == WorkInfo.State.FAILED) {
                                       message = workInfo.getOutputData().getString(NetworkConnected.KEY_FAILURE);
                                       alert(message);
                                   }

                               }
                           });

    /**
     * Returns {@code true} if this State is considered finished.
     *
     * @return {@code true} for {@link #SUCCEEDED}, {@link #FAILED}, and * {@link #CANCELLED}
     *         states
     */
    public boolean isFinished() {
        return (this == SUCCEEDED || this == FAILED || this == CANCELLED);
    }

WorkManager.getInstance().getWorkInfoByIdLiveData(workRequest.getId())
           .observe(this, new Observer<WorkInfo>() {
                       @Override
                       public void onChanged(WorkInfo workInfo) {
                           if (workInfo.getState().isFinished() {
                               if (workInfo.getState() == WorkInfo.State.SUCCEEDED) {
                                   message = workInfo.getOutputData().getString(NetworkConnected.KEY_SUCCESS);
                               }
                               else {
                                   message = workInfo.getOutputData().getString(NetworkConnected.KEY_FAILURE);
                               }

                               alert(message);
                           }
                       }
                   });