IPrint/app/src/main/java/com/epson/iprint/storage/StorageProcessUploadActivity.java

package com.epson.iprint.storage;

import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.p000v4.media.session.PlaybackStateCompat;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RadioGroup;
import android.widget.TextView;

import com.epson.iprint.storage.gdrivev3.GoogleV3UploadClient;
import com.epson.iprint.storage.gdrivev3.GoogleV3UploadSignInActivity;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

import epson.print.CommonDefine;
import epson.print.R;
import epson.print.ScanFileNumber;
import epson.print.Util.EPLog;
import epson.print.Util.Utils;
import epson.scan.lib.libHaru;
import epson.server.utils.MyUtility;

public class StorageProcessUploadActivity extends StorageProcessActivity {
    final String UPLOAD_EDITING_FILENAME = "Upload.Editing.Filename";
    List<String> mUploadFileLocalPathList;
    String mUploadFilename;

    private void onUpdateProcessView() {
    }

    protected void onCreate(Bundle bundle) {
        String string;
        super.onCreate(bundle);
        setContentView((int) R.layout.folder_content_layout_for_upload);
        setActionBar(getStorageClient().getStorageServiceName(this), true);
        final Button button = (Button) findViewById(R.id.save_button);
        button.setText(getString(R.string.upload_btn_label));
        button.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                String filename = getFilename();
                if (!getStorageClient().isValidUploadName(filename)) {
                    showErrorDialog((int) R.string.str_error_Filename);
                } else if (isConnected()) {
                    button.setEnabled(false);
                    UploadTask uploadTask = new UploadTask();
                    uploadTask.localPaths = new ArrayList(mUploadFileLocalPathList);
                    uploadTask.uploadFilename = filename;
                    uploadTask.fileType = getFiletype();
                    uploadTask.execute(new Void[0]);
                } else {
                    showConnectionError();
                }
            }
        });
        bindClearButton(R.id.upload_dialog_file_name, R.id.clear_name_btn, new StorageActivity.OnVisibilityListener() {
            public void onVisibilityChanged(int i) {
                setEnabledSaveButton(i == 0);
            }
        });
        mUploadFilename = generateUploadFilename(0);
        if (!(bundle == null || (string = bundle.getString("Upload.Editing.Filename")) == null)) {
            mUploadFilename = string;
        }
        setFilename(mUploadFilename);
        mUploadFileLocalPathList = getIntent().getStringArrayListExtra(StorageProcessActivity.EXTRA_UPLOADFILE_LIST);
        if (getStorageClient() instanceof GoogleV3UploadClient) {
            startActivity(GoogleV3UploadSignInActivity.getPlayServiceCheckIntent(this));
        }
    }

    protected void onSaveInstanceState(Bundle bundle) {
        super.onSaveInstanceState(bundle);
        mUploadFilename = getFilename();
        bundle.putString("Upload.Editing.Filename", mUploadFilename);
    }

    protected void onRestoreInstanceState(Bundle bundle) {
        super.onRestoreInstanceState(bundle);
        mUploadFilename = bundle.getString("Upload.Editing.Filename");
    }

    private void onSignInStatus(StorageProcessActivity.SignInStatus signInStatus) {
        updateUploadSection(signInStatus);
        updateSaveButton(signInStatus);
    }

    class UploadTask extends AsyncTask<Void, Void, Void> {
        boolean canceled;
        StorageServiceClient.UploadFileType fileType;
        List<String> localPaths;
        private volatile StorageServiceClient.ProcessError taskError;
        String uploadFilename;
        boolean uploaded;
        StorageServiceClient.Uploader uploader;

        UploadTask() {
        }

        protected Void doInBackground(Void... voidArr) {
            final ReentrantLock reentrantLock;
            final StorageActivity.OverlayProgress overlayProgress = new StorageActivity.OverlayProgress();
            overlayProgress.show(getString(R.string.uploading_notification), new StorageActivity.CancelRequestCallback() {
                public void onCancelRequest(Intent intent) {
                    if (uploader != null && uploader.isCancelable()) {
                        uploader.cancel();
                    }
                    canceled = true;
                }
            });
            String str = "";
            if (StorageServiceClient.UploadFileType.PDF.equals(fileType)) {
                String str2 = new File(localPaths.get(0)).getParent() + CommonDefine.SLASH + uploadFilename + CommonDefine.FileType_PDF;
                new libHaru().createPDF((ArrayList) localPaths, str2);
                localPaths.clear();
                localPaths.add(str2);
                str = CommonDefine.FileType_PDF;
            } else if (StorageServiceClient.UploadFileType.JPEG.equals(fileType)) {
                str = ".jpg";
            }
            boolean z = !this.uploadFilename.equals(generateUploadFilename(0));
            int size = localPaths.size();
            int i = 0;
            while (true) {
                if (i >= size) {
                    break;
                }
                String str3 = localPaths.get(i);
                String str4 = uploadFilename + str;
                if (size > 1) {
                    if (z) {
                        str4 = String.format("%s%03d%s", new Object[]{uploadFilename, Integer.valueOf(i + 1), str});
                    } else {
                        str4 = String.format("%s%s", new Object[]{generateUploadFilename(i), str});
                    }
                    overlayProgress.changeMessage(getString(R.string.uploading_notification) + (i + 1) + CommonDefine.SLASH + size);
                }
                reentrantLock = new ReentrantLock();
                final Condition newCondition = reentrantLock.newCondition();
                try {
                    reentrantLock.lock();
                    uploaded = false;
                    taskError = StorageServiceClient.ProcessError.NONE;
                    uploader = getStorageClient().getUploader(StorageProcessUploadActivity.this, fileType, str3, str4);
                    uploader.start(new StorageServiceClient.UploadCompletion() {
                        public void onUploadComplete(String str, String str2, StorageServiceClient.ProcessError processError) {
                            try {
                                reentrantLock.lock();
                                StorageServiceClient.ProcessError unused = taskError = processError;
                                uploaded = true;
                                newCondition.signal();
                            } catch (Exception e) {
                                EPLog.w("Storage", "onUploadComplete() exception <" + e.toString() + ">");
                            } catch (Throwable th) {
                                reentrantLock.unlock();
                                throw th;
                            }
                            reentrantLock.unlock();
                        }
                    });
                    while (uploaded) {
                        newCondition.await();
                    }
                    if (canceled && taskError == StorageServiceClient.ProcessError.NONE) {
                        reentrantLock.unlock();
                        i++;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    taskError = StorageServiceClient.ProcessError.ERROR;
                } catch (Throwable th) {
                    reentrantLock.unlock();
                    throw th;
                }
            }
            if (canceled) {
                taskError = StorageServiceClient.ProcessError.CANCELED;
            }
            reentrantLock.unlock();
            runOnUiThread(new Runnable() {
                public void run() {
                    if (taskError == StorageServiceClient.ProcessError.NONE) {
                        overlayProgress.dismiss();
                        finish();
                        return;
                    }
                    setEnabledSaveButton(true);
                    if (taskError == StorageServiceClient.ProcessError.ERROR) {
                        showErrorDialog((int) R.string.upload_error_mes);
                    }
                    overlayProgress.dismiss();
                }
            });
            return null;
        }
    }

    private void updateUploadSection(StorageProcessActivity.SignInStatus signInStatus) {
        ViewGroup viewGroup = (ViewGroup) findViewById(R.id.upload_file_name_file_type_section);
        if (signInStatus == StorageProcessActivity.SignInStatus.SIGNED_IN) {
            viewGroup.setVisibility(0);
            ((RadioGroup) findViewById(R.id.file_type_for_upload)).check(R.id.pdf_type);
            List<String> list = mUploadFileLocalPathList;
            if (list != null && list.size() > 0) {
                setFilename(mUploadFilename);
            }
            ((TextView) findViewById(R.id.file_size)).setText(getTotalFileSize(mUploadFileLocalPathList));
            return;
        }
        viewGroup.setVisibility(4);
    }

    private void updateSaveButton(StorageProcessActivity.SignInStatus signInStatus) {
        setEnabledSaveButton(signInStatus == StorageProcessActivity.SignInStatus.SIGNED_IN);
    }

    private void setEnabledSaveButton(boolean z) {
        Button button = (Button) findViewById(R.id.save_button);
        if (z) {
            button.setEnabled(true);
        } else {
            button.setEnabled(false);
        }
    }

    private String getFilename() {
        return ((TextView) findViewById(R.id.upload_dialog_file_name)).getText().toString();
    }

    private void setFilename(String str) {
        ((EditText) findViewById(R.id.upload_dialog_file_name)).setText(str);
    }

    private StorageServiceClient.UploadFileType getFiletype() {
        return ((RadioGroup) findViewById(R.id.file_type_for_upload)).getCheckedRadioButtonId() == R.id.pdf_type ? StorageServiceClient.UploadFileType.PDF : StorageServiceClient.UploadFileType.JPEG;
    }

    private String generateUploadFilename(int i) {
        int count = ScanFileNumber.getCount(this);
        return "EPSON" + new Utils().editNumber(count + i);
    }

    private String getTotalFileSize(List<String> list) {
        Long l = 0L;
        for (String file : list) {
            l = Long.valueOf(l.longValue() + new File(file).length());
        }
        double longValue = (double) (l.longValue() / PlaybackStateCompat.ACTION_PLAY_FROM_MEDIA_ID);
        if (longValue > 500.0d) {
            return MyUtility.mathRound(longValue / 1024.0d, 2) + "MB";
        }
        return MyUtility.mathRound(longValue, 2) + "KB";
    }
}