Android 从活动更新IntentService的数据

我有一个

IntentService

将图像上传到服务器（以下来源）。上载过程中，用户可能会选择更多要上载的图像。现在它产生了另一个服务。如何将数据添加到同一个正在运行的服务中，或在该服务未运行时生成新服务

public class UploadService extends IntentService {

    public static final String TAG = UploadService.class.getSimpleName();

    public static final String ACTION_UPLOAD = UploadService.class.getName() + ".UPLOAD";
    public static final String EXTRA_RESOURCE_ID = "resource_id";
    public static final String EXTRA_RESOURCE_NAME = "resource_name";
    public static final String EXTRA_IMAGES = "images";

    private static final int CONCURRRENT_UPLOAD_COUNT = 3;
    private static final int UPLOAD_STATUS_PENDING = 0;
    private static final int UPLOAD_STATUS_UPLOADING = 1;
    private static final int UPLOAD_STATUS_UPLOADED = 2;
    private static final int UPLOAD_STATUS_FAILED = 3;
    private static final int UPLOAD_STATUS_TERMINATED = 4;

    private ArrayList<DiskImage> mImages = new ArrayList<>();
    private ArrayMap<DiskImage, Integer> mStatusMap = new ArrayMap<>();
    private OkHttpClient mOkHttpClient = new OkHttpClient();

    public UploadService() {
        super(TAG);
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        if (intent.getAction().equals(ACTION_UPLOAD)) {
            String resId = intent.getStringExtra(EXTRA_RESOURCE_ID);
            String resName = intent.getStringExtra(EXTRA_RESOURCE_NAME);
            ArrayList<DiskImage> images = intent.getParcelableArrayListExtra(EXTRA_IMAGES);
            for (DiskImage image : images) {
                image.mUploadId = resId;
                image.mUploadResName = resName;
            }
            mImages.addAll(images);
            upload(); // start the upload
            updateNotification();
        }
    }

    private int getUploadedImageCount() {
        int count = 0;
        for (int i = 0; i < mImages.size(); i++)
            if (getStatus(mImages.get(i)) == UPLOAD_STATUS_UPLOADED)
                count++;
        return count;
    }

    private void updateNotification() {
        UploadNotification.notify(UploadService.this, mImages.size(), getUploadedImageCount());
    }

    private void upload() {
        final DiskImage image = getImageToUpload();
        if (image != null) {
            // show notification
            MediaType mediaType = MediaType.parse(image.mimeType);
            RequestBody requestBody = new MultipartBody.Builder()
                    .setType(MultipartBody.FORM)
                    .addFormDataPart("resource_id", image.mUploadId)
                    .addFormDataPart("resource_name", image.mUploadResName)
                    .addFormDataPart("image", getName(image.path),
                            RequestBody.create(mediaType, new File(image.path)))
                    .build();
            Request request = new Request.Builder()
                    .url(getUploadUrl())
                    .post(requestBody)
                    .build();
            mStatusMap.put(image, UPLOAD_STATUS_UPLOADING);
//            Log.i(TAG, "Uploading image " + getName(image.path));
            mOkHttpClient.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Call call, IOException e) {
                    mStatusMap.put(image, UPLOAD_STATUS_FAILED);
                    // add failed image in end
                    mImages.remove(image);
                    mImages.add(image);
//                    Log.i(TAG, "Upload failed " + getName(image.path));
                    upload();
                    e.printStackTrace();
                }

                @Override
                public void onResponse(Call call, Response response) throws IOException {
//                    Log.i(TAG, "Uploaded image " + getName(image.path) + " Response: " + response.body().string());
                    mStatusMap.put(image, UPLOAD_STATUS_UPLOADED);
                    upload(); // upload next image
                    updateNotification();
                }
            });
        }
    }

    private String getName(String path) {
        return path.substring(path.lastIndexOf(File.separator) + 1, path.length());
    }

    private DiskImage getImageToUpload() {
        for (int i = 0; i < mImages.size(); i++)
            if (getStatus(mImages.get(i)) == UPLOAD_STATUS_PENDING)
                return mImages.get(i);
        return null;
    }

    private String getUploadUrl() {
        return String.format(Constants.ALBUM_IMAGE_UPLOAD_URL, Preferences.getToken(this));
    }

    private int getStatus(DiskImage image) {
        if (mStatusMap.get(image) == null)
            return UPLOAD_STATUS_PENDING;
        return mStatusMap.get(image);
    }

}

公共类上传服务扩展了IntentService{
public static final String TAG=UploadService.class.getSimpleName（）；
public static final String ACTION_UPLOAD=UploadService.class.getName（）+“.UPLOAD”；
公共静态最终字符串EXTRA\u RESOURCE\u ID=“RESOURCE\u ID”；
公共静态最终字符串EXTRA\u RESOURCE\u NAME=“RESOURCE\u NAME”；
公共静态最终字符串EXTRA_IMAGES=“IMAGES”；
私有静态最终int concurrent\u UPLOAD\u COUNT=3；
私有静态最终整数上传\状态\挂起=0；
私有静态最终整数上传\状态\上传=1；
私有静态最终整数上传\状态\上传=2；
私有静态最终整数上传\状态\失败=3；
私有静态最终整数上传\状态\终止=4；
private ArrayList mImages=new ArrayList（）；
private ArrayMap mStatusMap=new ArrayMap（）；
私有OkHttpClient mOkHttpClient=新OkHttpClient（）；
公共上传服务（）{
超级（标签）；
}
@凌驾
受保护的手部内容无效（意图）{
if（intent.getAction（）.equals（ACTION_UPLOAD））{
String resId=intent.getStringExtra（额外资源ID）；
String resName=intent.getStringExtra（额外资源名称）；
arraylistimages=intent.getParcelableArrayListExtra（额外图像）；
用于（磁盘映像映像：映像）{
image.mUploadId=resId；
image.muploandresname=resName；
}
mImages.addAll（图像）；
upload（）；//开始上传
更新化（）；
}
}
私有int getUploadedImageCount（）{
整数计数=0；
对于（int i=0；i

你不能只

扩展服务

（而不是

IntentService

），将你的活动绑定到服务，然后调用此服务的一个方法来上传图片

这样，您的服务将一直运行，直到您在服务中调用

stopSelf（）

，或在您的绑定活动中调用

stopService（）

。因此，您可以使用同一服务进行多次上载

请让我知道这个答案是否有帮助