erpsuiteandroid/RA Image/app/src/main/java/com/usai/util/RAUploadManager.java

package com.usai.util;

import android.content.SharedPreferences;
import android.os.Bundle;
import android.util.Base64;
import android.util.Log;

import com.usai.redant.raimage.RedAntApplication;

import org.json.JSONException;
import org.json.JSONObject;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

import static com.usai.util.Network.URL_UPLOAD;

/**
 * Created by ray on 13/06/2017.
 */

public class RAUploadManager {
    public int maxThread=3;
    public int activeThread;
    public int maxRetry=2;

    public Boolean autoStart=true;
    public Boolean removeFinish=true;
    public Boolean removeError=false;
    public QueueStatus queue_status;


    public static final  int RESULT_BARCODE_ERROR=-50;

    public TaskStatus newtaskStatus= TaskStatus.TaskStatusWait;
    public ArrayList<Bundle> arr_queue;
//    private List<Bundle> operation_queue;
//    private ExecutorService es = Executors.newFixedThreadPool(3);//
    // .newFixedThreadPool();
//    private CountDownLatch latch = new CountDownLatch(maxThread);
    private RAOperationQueue operation_queue;
    public enum QueueStatus {
        QueueStatusDefault,
        QueueStatusAdd,
        QueueStatusError,
        QueueStatusFinishWithError,
        QueueStatusFinish
    }

    public enum TaskStatus {
        TaskStatusStop,
        TaskStatusStart,
        TaskStatusError,
        TaskStatusWait,
        TaskStatusFinish,
        TaskStatusCancel,
    }

    public UIUpdateListener uiUpdateListener;

    public interface UIUpdateListener {
        void onProgress(long index, double percentage);
        void updateCell(long index, Bundle taskinfo);
        void updateList();

//        void onFinish(int code, String res/*, HashMap<String, List<String>> headers*/);
    }


//    class Poll implements Runnable {
//        public void run() {
//            // while (queue.size()>0) {
//            while (!operation_queue.isEmpty()) {
//                System.out.println(operation_queue.poll());
//            }
//            latch.countDown();
//        }
//    }

    public RAUploadManager()
    {
        queue_status = QueueStatus.QueueStatusDefault;



        SharedPreferences UMSetting = RedAntApplication.getInstance()
                .getSharedPreferences("UploadManager", 0);

        if(UMSetting!=null)
        {
            autoStart = UMSetting.getBoolean("auto_upload",true);
            removeFinish = UMSetting.getBoolean("auto_rm_finish",true);
            removeError = UMSetting.getBoolean("auto_rm_error",false);
            maxRetry = UMSetting.getInt("retry_count",2);
            newtaskStatus = TaskStatus.values()[UMSetting.getInt("newtask_status",TaskStatus.TaskStatusWait.ordinal())];

            maxThread = UMSetting.getInt("max_thread",3);



        }
        operation_queue = new RAOperationQueue();
        operation_queue.setCallback(new RAOperationQueue.OperationCallback() {
            @Override
            public Boolean operate(final Bundle taskinfo) {

                boolean ret=false;
                String path=taskinfo.getString("path");
                String url=taskinfo.getString("url")+""+URL_UPLOAD;

                JSONObject result=Network.UploadImage(path, taskinfo.getBundle("params"), url, new Network.FileUploadListener() {
                    @Override
                    public boolean interupt() {
//                        if(taskinfo.getBoolean("iscancel",false))
//                            return false;
                        return taskinfo.getBoolean("iscancel",false);
                    }

                    @Override
                    public void onProgress(long pro, double percentage) {


                        synchronized(this){
                            Log.d("", "onProgress: " + percentage);
                            taskinfo.putDouble("progress",percentage);
                            if (uiUpdateListener!=null) {
                                int index = arr_queue.indexOf(taskinfo);
//                            uiUpdateListener.onProgress(index,percentage);

                                uiUpdateListener.updateCell(index,taskinfo);
                            }
                        }


                    }

                    @Override
                    public void onFinish(int code, String res) {
                        Log.d("", "onFinish: ");

                    }
                });
                int r = 0;
                try {
                    r = result.getInt("result");
                    String rmsg=result.getString("msg");

                    if(r==2|| r==RESULT_BARCODE_ERROR)
                    {
                        taskinfo.putInt("status",TaskStatus.TaskStatusFinish.ordinal());
                        if(r==2)
                            taskinfo.putString("msg","upload successful");
                        else
                            taskinfo.putString("msg","warring: "+rmsg );
                    }
                    else
                    {
                        if(taskinfo.getInt("retry",0)>=maxRetry)
                        {
                            taskinfo.putInt("status",TaskStatus.TaskStatusError.ordinal());
                            taskinfo.putDouble("progress",0.0);
                            taskinfo.putString("msg",rmsg);
                        }
                        else
                        {
                            taskinfo.putInt("retry",taskinfo.getInt("retry",0)+1);
                            taskinfo.putInt("status",TaskStatus.TaskStatusWait.ordinal());
                            taskinfo.putDouble("progress",0.0);
                            taskinfo.putString("msg","connection lost, retry...");
                            ret=true;

                        }
                    }






                } catch (JSONException e) {
//                    String rmsg=result.getString("msg");
                    taskinfo.putInt("status",TaskStatus.TaskStatusError.ordinal());
                    taskinfo.putDouble("progress",0.0);
                    taskinfo.putString("msg","can not upload, please contact administrator.");
                    e.printStackTrace();
                }
                finally {
                    synchronized (this)
                    {
                        if (uiUpdateListener!=null) {
                            int index = arr_queue.indexOf(taskinfo);

                            uiUpdateListener.updateCell(index,taskinfo);
                        }
                    }
                }

                return ret;
//                int a=0;
//                System.out.println(a+"running  tid="+Thread.currentThread().getId());
//                int min=1000;
//                int max=5000;
//                int sleep=new Random().nextInt(max)%(max-min+1) + min;
//                try{
//                    Thread.currentThread().sleep(sleep);
//                }catch(InterruptedException ie){
//                    ie.printStackTrace();
//                }
//                System.out.println(a+"   "+sleep+"     finish  tid="+Thread.currentThread().getId());

            }

            @Override
            public void operateFinish(Bundle taskinfo) {

                TaskStatus status= TaskStatus.values()[taskinfo.getInt("status",0)];
                boolean removefromlist=false;
                if (status==TaskStatus.TaskStatusFinish&&removeFinish)
                    removefromlist=true;
                else if (status==TaskStatus.TaskStatusError&&removeError)
                    removefromlist=true;

                synchronized (this)
                {

                    if(removefromlist)
                    {
                            arr_queue.remove(taskinfo);
                        if(uiUpdateListener!=null)
                            uiUpdateListener.updateList();


                    }



                        saveTasks();


                }


            }
        });

        //            operation_queue = new List<Bundle>() {};

        loadTask();

    }

    private void loadTask()
    {
        stopAllTasks();
        arr_queue = new ArrayList<Bundle>();



        Log.d("_RAIMAGE", "saveTasks: RAUploadManager");

        SharedPreferences pref = RedAntApplication.getInstance()
                .getSharedPreferences("RA Image", 0);
        try {
        String tasksBase64 = pref.getString("task_list", "");


//            ArrayList<String> wrap_arr = new ArrayList<String>();
//            for( Bundle b:arr_queue)
//            {
//                String sjson=RAUtil.Bundle2Json(b).toString();
//                Log.d("_RAIMAGE", "saveTasks: "+sjson);
//                wrap_arr.add(sjson);
//            }
//
//            ByteArrayOutputStream baos = new ByteArrayOutputStream();
//            ObjectOutputStream oos = new ObjectOutputStream(baos);
//            oos.writeObject(wrap_arr);
//
//            String tasksBase64 = android.util.Base64.encodeToString(baos.toByteArray(), android.util.Base64.DEFAULT);//new String(Base64.encodeBase64(baos.toByteArray()));
//
//
//            editor.putString("task_list", tasksBase64);
//
//
//            editor.commit();

            if(tasksBase64.length()>0)
            {
                byte[] decode=Base64.decode(tasksBase64,Base64.DEFAULT);
                ByteArrayInputStream bais= new ByteArrayInputStream(decode);

                ObjectInputStream ois = null;

                ois = new ObjectInputStream(bais);

                ArrayList<String> arr_load=(ArrayList<String>)ois.readObject();
                for(String s:arr_load)
                {
                    Log.d("_RAIMAGE", "loadTask: "+s);
                    JSONObject jsobj = new JSONObject(s);
                    Bundle b=RAUtil.Json2Bundle(jsobj);
                    arr_queue.add(b);
//                                String sjson=RAUtil.Bundle2Json(b).toString();

//                wrap_arr.add(sjson);
                }
            }


        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (JSONException e) {
            e.printStackTrace();
        }
        for(Bundle b:arr_queue)
        {
            startTask(b);
        }
//            int a = 0;
        // 此处缺少读取持久话保存任务队列的实现。
    }

    public void addTask(Bundle task)
    {
        arr_queue.add(task);
        synchronized (this)
        {

            saveTasks();
        }
        if(newtaskStatus== TaskStatus.TaskStatusWait)
        {
            startTask(task);
        }
    };
    public void addTasks(ArrayList<Bundle> tasks)
    {
        arr_queue.addAll(tasks);
        synchronized (this)
        {

            saveTasks();
        }
        if(newtaskStatus== TaskStatus.TaskStatusWait)
        {
            for (Bundle task:tasks)
            {
                startTask(task);
            }

        }

    };
    public void startTask(Bundle task)
    {

        operation_queue.addOperation(task);



    };
    public void clearTask()
    {
        ArrayList<Bundle> remove = new ArrayList<Bundle>();
        for(Bundle b:arr_queue)
        {
            if(TaskStatus.values()[b.getInt("status",0)]==TaskStatus.TaskStatusStart||TaskStatus.values()[b.getInt("status",0)]==TaskStatus.TaskStatusWait)
                continue;
            remove.add(b);
//            removeTask(b);
        }
        removeTasks(remove);



    }
    public void removeTask(Bundle task)
    {

        arr_queue.remove(task);
        synchronized (this)
        {
            saveTasks();
        }

        String path = filePath(task);
        File file = new File(path);
        if(file.exists())
        {
            file.delete();
        }

    };
    public void removeTasks(List<Bundle> tasks)
    {
        arr_queue.removeAll(tasks);
        synchronized (this)
        {
            saveTasks();
        }
        for(Bundle task:tasks)
        {

            String path = filePath(task);
            File file = new File(path);
            if(file.exists())
            {
                file.delete();
            }
        }
    };
    public void stopAllTasks()
    {
        if(arr_queue==null)
            return;
        for (Bundle task:arr_queue)
        {
            stopTask(task);
        }
    };
    public void stopTask(Bundle task)
    {
        if(task.getInt("status")!= TaskStatus.TaskStatusStart.ordinal()&&task.getInt("status")!= TaskStatus.TaskStatusWait.ordinal())
            return;

        task.putBoolean("iscancel",true);
//        long tid=task.getLong("tid",-1);
//        if(tid>0)
//        {
//
//
//        }
//        task.tet("tid",Thread.currentThread().getId());

//        RAUploadOperation


    }
    public void saveTasks()
    {

        Log.d("_RAIMAGE", "saveTasks: RAUploadManager");

        SharedPreferences pref = RedAntApplication.getInstance()
                .getSharedPreferences("RA Image", 0);
        SharedPreferences.Editor editor = pref.edit();

        try {

            ArrayList<String> wrap_arr = new ArrayList<String>();
            for( Bundle b:arr_queue)
            {
                String sjson=RAUtil.Bundle2Json(b).toString();
                Log.d("_RAIMAGE", "saveTasks: "+sjson);
                wrap_arr.add(sjson);
            }

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(wrap_arr);

            String tasksBase64 = android.util.Base64.encodeToString(baos.toByteArray(), android.util.Base64.DEFAULT);//new String(Base64.encodeBase64(baos.toByteArray()));


            editor.putString("task_list", tasksBase64);


            editor.commit();

//            byte[] decode=Base64.decode(personBase64,Base64.DEFAULT);
//            ByteArrayInputStream bais= new ByteArrayInputStream(decode);
//
//            ObjectInputStream ois = new ObjectInputStream(bais);
//            ArrayList<String> arr_load=(ArrayList<String>)ois.readObject();
//            int a = 0;

        }
        catch (Exception e)
        {
            e.printStackTrace();

        }


//        if (m_swSave.isChecked()&&!TextUtils.isEmpty(encryptPass)&&!TextUtils.isEmpty(encryptUser))
//        {
//            editor.putString("user", encryptUser);
//            editor.putString("password", encryptPass);
//            editor.putBoolean("kepppass", true);
//        }
//        else
//        {
//            editor.putString("user", null);
//            editor.putString("password", null);
//            editor.putBoolean("kepppass", false);
//        }
//
//        editor.puts
//
//        editor.commit();

    };



    private String filePath(Bundle task)
    {
//        String path = Environment.getExternalStorageDirectory().getPath();
//        path+="/"+task.getString("path");
//        path+="/"+task.getString("file");

        return task.getString("path","");
    }


}