修复问卷做过有答案不显示的问题

0979a476 · xuqinghao · 17cde0fc · 0979a476
Commit 0979a476 authored Oct 18, 2023 by xuqinghao
Hide whitespace changes
Inline Side-by-side

Showing with 849 additions and 846 deletions

StuQuestionnaireMainActivity.java ...onnaire/mvp/ui/activity/StuQuestionnaireMainActivity.java +849 -846

No files found.
--- a/teachinteraction/src/main/java-que/com/offcn/teachinteraction/questionnaire/mvp/ui/activity/StuQuestionnaireMainActivity.java
+++ b/teachinteraction/src/main/java-que/com/offcn/teachinteraction/questionnaire/mvp/ui/activity/StuQuestionnaireMainActivity.java
 package com.offcn.teachinteraction.questionnaire.mvp.ui.activity;
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 import android.util.ArrayMap;
 import android.view.View;
 import android.view.WindowManager;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 import com.alibaba.android.arouter.facade.annotation.Route;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import com.gyf.immersionbar.ImmersionBar;
 import com.gyf.immersionbar.OnKeyboardListener;
 import com.offcn.kxframework.base.BaseActivity;
 import com.offcn.kxframework.di.component.KxAppComponent;
 import com.offcn.kxframework.utils.OffcnUtils;
 import com.offcn.offcn_commonsdk.core.RouterHub;
 import com.offcn.offcn_commonsdk.event.StuRefreshHwListEvent;
 import com.offcn.offcn_commonsdk.utils.ButtonClickCtrlUtil;
 import com.offcn.offcn_commonsdk.utils.OffcnDataUtil;
 import com.offcn.offcn_commonsdk.utils.OffcnDeviceUtil;
 import com.offcn.teachinteraction.R;
 import com.offcn.teachinteraction.databinding.InterActivityStuQuestionnaireMainBinding;
 import com.offcn.teachinteraction.mvp.view.StuServiceDialog;
 import com.offcn.teachinteraction.questionnaire.adapter.StuQuestionnaireMainAdapter;
 import com.offcn.teachinteraction.questionnaire.bean.questionnaire.QuestionnaireBaseInfoBean;
 import com.offcn.teachinteraction.questionnaire.bean.questionnaire.QuestionnaireQuestionAnswerBean;
 import com.offcn.teachinteraction.questionnaire.bean.questionnaire.QuestionnaireQuestionBean;
 import com.offcn.teachinteraction.questionnaire.bean.questionnaire.QuestionnaireQuestionType;
 import com.offcn.teachinteraction.questionnaire.bean.questionnaire.QuestionnaireStatus;
 import com.offcn.teachinteraction.questionnaire.di.component.DaggerStuQuestionnaireMainComponent;
 import com.offcn.teachinteraction.questionnaire.mvp.contract.StuQuestionnaireMainContract;
 import com.offcn.teachinteraction.questionnaire.mvp.presenter.StuQuestionnaireMainPresenter;
 import com.offcn.teachinteraction.questionnaire.mvp.ui.fragment.questionnaire.StuQuestionnaireEachFragment;
 import com.offcn.teachinteraction.questionnaire.widget.StuQuestionnaireSubmitSuccessDialog;
 import com.offcn_commonres.wigdet.ExamMaterialViewPager;
 import com.offcn_commonres.wigdet.OffcnLoadingDialog;
 import com.offcn_commonres.wigdet.ToastUtils;
 import org.greenrobot.eventbus.EventBus;
 import org.json.JSONArray;
 import org.json.JSONObject;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.viewpager.widget.ViewPager;
 import io.reactivex.Observable;
 import io.reactivex.ObservableEmitter;
 import io.reactivex.ObservableOnSubscribe;
 import io.reactivex.Observer;
 import io.reactivex.android.schedulers.AndroidSchedulers;
 import io.reactivex.disposables.Disposable;
 import io.reactivex.schedulers.Schedulers;
 import static com.offcn.kxframework.utils.Preconditions.checkNotNull;
 /**
 * 问卷操作主页面
 */
 @Route(path = RouterHub.INTER_STUQUESTIONNAIRMAINACTIVITY)
 public class  StuQuestionnaireMainActivity extends BaseActivity<StuQuestionnaireMainPresenter, InterActivityStuQuestionnaireMainBinding> implements StuQuestionnaireMainContract.View {
    private String source_id;                           // 问卷id (必传，不能为空)
    private int paperStatus;                            // 问卷状态 (必传，不能<=0)
    private String curriculum_id;                       // 互动课程id (如果是第一次作答或者重新作答必传，不能为空)
    private String knobble_id;                          // 小节id(如果是第一次作答或者重新作答必传，不能为空)
    private String class_id;                            // 班级id 非公开课必传 (如果是第一次作答或者重新作答必传，不能为空)
    private String answer_id;                           // 作答id（如果是第一次作答或者重新作答那么无需传递，查看作答记录必传）
    private int que_type;
    private String extend_param;                    //班级评价及未来其它类型扩展字段
    private String que_title;                          //外部标题
    private final int ANSWER_PARSE_COMPLETE = 10001;                                                   // 答案解析完毕的消息对象
    private final int QUESTION_PARSE_COMPLETE = 10002;                                                 // 题目解析完毕的消息对象
    private ImageView ivBack;                                                                          // 回退按钮
    private TextView tvTitle;                                                                          // 主标题
    private ExamMaterialViewPager vpMain;                                                              // 主内容展示器
    private View vBottomLine;                                                                          // 底部栏顶部边线（默认隐藏）
    private LinearLayout llMainBottomBar;                                                              // 底部栏（默认隐藏）
    private TextView tvPreviousQuestion;                                                               // 上一题按钮
    private TextView tvNextQuestion;                                                                   // 下一题按钮
    private int nextEnableRes;                                                                          // 下一题按钮可用的是否的背景
    private int nextDisableRes;                                                                         // 下一题按钮不可用的是否的背景
    private boolean nextBtnStatus;                                                                      // 下一题按钮的状态
    private Activity context;                                                                           // 上下文对象
    private OffcnLoadingDialog loadingDialog;                                                           // 加载中的对话框
    private ButtonClickCtrlUtil btnCtrlUtil;                                                            // 防暴力点击工具
    private QuestionnaireBaseInfoBean baseInfoBean;                                                     // 试卷基本信息
    private QuestionnaireStatus questionnaireStatus;                                                    // 问卷的状态（填写中/查看记录）
    private ArrayMap<Integer, QuestionnaireQuestionAnswerBean> idAnswerMap;                             // 试题编号和试题答案之间的关联表
    private ArrayList<QuestionnaireQuestionBean> questionList;                                          // 题目列表
    private StuQuestionnaireMainAdapter mainAdapter;                                                    // 主列表适配器
    private HashMap<String, String> pictureCache = new HashMap<>();                                     // 用于缓存图片展示的存储
    private boolean hasQuestionParseComplete;                                                           // 题目解析是否完成
    private boolean hasAnswerParseComplete;                                                             // 答案解析是否完成
    private StuQuestionnaireEachFragment curShowFragment;                                               // 当前正在展示的子页面
    private StuQuestionnaireSubmitSuccessDialog submitSuccessDialog;                                    // 提交数据成功的对话框
    private StuServiceDialog backSpaceDialog;                                                           // 回退对话框
    private Handler handler = new Handler(Looper.getMainLooper()) {                                     // 特殊操作处理
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            // 如果本页面已经销毁，那么什么事都不做了
            if (context == null || context.isDestroyed()) {
                return;
            }
            switch (msg.what) {
                // 答案解析完毕的消息对象
                case ANSWER_PARSE_COMPLETE:
                    hasAnswerParseComplete = true;
                    // 如果当前题目解析已经完成的话，那么开始展示数据
                    if (hasQuestionParseComplete) {
                        initQuestionPageAdapter();
                    }
                    break;
                // 题目解析完毕的消息对象
                case QUESTION_PARSE_COMPLETE:
                    hasQuestionParseComplete = true;
                    Boolean hasAnswerResult = (Boolean) msg.obj;
                    // 如果当前存在答案解析并且已经完成答案解析的话，那么开始展示数据
                    if (hasAnswerResult) {
                        if (hasAnswerParseComplete) {
                            initQuestionPageAdapter();
                        }
                    }
                    // 不存在答案解析，那么直接展示数据
                    else {
                        initQuestionPageAdapter();
                    }
                    break;
            }
        }
    };
    @Override
    public void setupActivityComponent(@NonNull KxAppComponent appComponent) {
        DaggerStuQuestionnaireMainComponent //如找不到该类,请编译一下项目
                .builder()
                .appComponent(appComponent)
                .view(this)
                .build()
                .inject(this);
    }
    @Override
    public InterActivityStuQuestionnaireMainBinding initView(@Nullable Bundle savedInstanceState) {
        return InterActivityStuQuestionnaireMainBinding.inflate(getLayoutInflater());
    }
    @Override
    public void initData(@Nullable Bundle savedInstanceState) {
        context = StuQuestionnaireMainActivity.this;
        // 校验传入参数
        if (!checkBaseData()) {
            finish();
            return;
        }
        // 生成工具bean
        btnCtrlUtil = new ButtonClickCtrlUtil();
        loadingDialog = new OffcnLoadingDialog(context, "");
        // 绑定视图
        bindViews();
        // 调整头顶状态栏的文字颜色
        ImmersionBar.with(context).statusBarDarkFont(true).keyboardEnable(true)
                .keyboardEnable(true)  //解决软键盘与底部输入框冲突问题，默认为false，还有一个重载方法，可以指定软键盘mode
                .keyboardMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE)  //单独指定软键盘模式
                .setOnKeyboardListener(new OnKeyboardListener() {
                    @Override
                    public void onKeyboardChange(boolean isPopup, int keyboardHeight) {
                        if (questionnaireStatus == QuestionnaireStatus.Filling) {
                            if (isPopup) {
                                // 底部栏的隐藏需要立即执行
                                llMainBottomBar.setVisibility(View.GONE);
                                vBottomLine.setVisibility(View.GONE);
                            } else {
                                // 延迟显示底部栏，防止闪动
                                llMainBottomBar.postDelayed(new Runnable() {
                                    @Override
                                    public void run() {
                                        vBottomLine.setVisibility(View.VISIBLE);
                                        llMainBottomBar.setVisibility(View.VISIBLE);
                                        llMainBottomBar.removeCallbacks(this);
                                    }
                                }, 16);
                            }
                        }
                    }
                }).init();
        // 获取到当前问卷的状态
        questionnaireStatus = QuestionnaireStatus.getByValue(paperStatus);
        // 如果当前是查看记录状态，那么所有页面可以随意滑动，否则需要根据子页面状态调节滑动操作
        vpMain.setCanScroll(QuestionnaireStatus.Completed == questionnaireStatus);
        // 获取到资源
        nextEnableRes = R.drawable.inter_selector_168bff_4dp_to_1583f0_4dp;
        nextDisableRes = R.drawable.inter_shape_e4e4e4_4dp;
        // 获取网络问卷基本数据并显示
        mPresenter.getStuQuestionnaireBaseInfo(source_id, class_id);
    }
    // 校验传入参数
    private boolean checkBaseData() {
        source_id = getIntent().getStringExtra("source_id");
        curriculum_id = getIntent().getStringExtra("curriculum_id");
        knobble_id = getIntent().getStringExtra("knobble_id");
        class_id = getIntent().getStringExtra("class_id");
        answer_id = getIntent().getStringExtra("answer_id");
        paperStatus = getIntent().getIntExtra("paperStatus",1);
        que_type =  getIntent().getIntExtra("que_type",0);//班级评价为1，普通问卷为0
        extend_param = getIntent().getStringExtra("extend_param");//班级评价及未来其它类型扩展字段
        que_title= getIntent().getStringExtra("que_title");//外部标题
        if (isEmpty()) {
            ToastUtils.showToast(context, context.getString(R.string.inter_str_parameter_passing_error));
            return false;
        }
        return true;
    }
    public boolean isEmpty() {
        // 试卷编号不能为空，试卷状态必须正确
        boolean firstCondition = OffcnDataUtil.isEmpty(source_id) || paperStatus < QuestionnaireStatus.Filling.getValue() || paperStatus > QuestionnaireStatus.Completed.getValue();
        // 如果当前是查看记录状态，那么作答记录编号不能为空
        boolean secondCondition = false;
        switch (QuestionnaireStatus.getByValue(paperStatus)) {
            case Filling:
                secondCondition =((que_type==0)?(OffcnDataUtil.isEmpty(curriculum_id) || OffcnDataUtil.isEmpty(knobble_id)):OffcnDataUtil.isEmpty(extend_param))|| OffcnDataUtil.isEmpty(class_id);
                break;
            case Completed:
                secondCondition = OffcnDataUtil.isEmpty(answer_id);
                break;
        }
        return firstCondition || secondCondition;
    }
    // 绑定视图
    private void bindViews() {
        if (mBinding != null) {
            ivBack = mBinding.ivBack;
            tvTitle = mBinding.tvTitle;
            vpMain = mBinding.vpMain;
            vBottomLine = mBinding.vBottomLine;
            llMainBottomBar = mBinding.llMainBottomBar;
            tvPreviousQuestion = mBinding.tvPreviousQuestion;
            tvNextQuestion = mBinding.tvNextQuestion;
            // 添加点击监听器
            View.OnClickListener onClickListener = new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    if (btnCtrlUtil.isFastDoubleClick()) return;
                    int id = view.getId();
                    // 回退
                    if (id == R.id.ivBack) {
                        // 根据不同的状态执行不同的操作
                        switch (questionnaireStatus) {
                            // 填写中
                            case Filling:
                                showBackSpaceDialog();
                                break;
                            // 查看记录
                            case Completed:
                                finish();
                                break;
                        }
                    }
                    // 上一题按钮
                    else if (id == R.id.tvPreviousQuestion) {
                        if (vpMain.getCurrentItem() != 0) {
                            if (curShowFragment != null) {
                                putAnswerResult(curShowFragment.getResult());
                            }
                            vpMain.setCurrentItem(vpMain.getCurrentItem() - 1, true);
                        }
                    }
                    // 下一题按钮
                    else if (id == R.id.tvNextQuestion) {
                        // 如果当前不能点击下一题，给出提示信息
                        if (!nextBtnStatus) {
                            if (curShowFragment != null) {
                                ToastUtils.showToast(context, curShowFragment.getNextDisableReason());
                            }
                        }
                        // 否则执行跳转到下一题
                        else if (vpMain.getCurrentItem() != questionList.size() - 1) {
                            if (curShowFragment != null) {
                                putAnswerResult(curShowFragment.getResult());
                            }
                            vpMain.setCurrentItem(vpMain.getCurrentItem() + 1, true);
                        }
                        // 否则执行数据提交操作
                        else {
                            // 异步生成作答结果并提交
                            requestSubmitAnswerResult();
                        }
                    }
                }
            };
            mBinding.ivBack.setOnClickListener(onClickListener);
            mBinding.tvPreviousQuestion.setOnClickListener(onClickListener);
            mBinding.tvNextQuestion.setOnClickListener(onClickListener);
        }
    }
    // 更新标题数据内容，然后请求问卷题目数据
    @Override
    public void initBaseInfoResponseData(QuestionnaireBaseInfoBean infoBean) {
        if (infoBean == null) {
            ToastUtils.showToast(context, "问卷信息获取失败");
            return;
        }
        baseInfoBean = infoBean;
        // 执行界面数据操作
        if(que_type==1){//
            tvTitle.setText(OffcnDataUtil.isEmpty(que_title)?baseInfoBean.getTitle():que_title);
        }else {
            tvTitle.setText(baseInfoBean.getTitle());
        }
        // 继续请求问卷题目数据
        mPresenter.getStuQuestionnaireContentList(source_id, answer_id);
    }
    // 启动分线程执行题目数据转换操作
    @Override
    public void initQuestionSourceList(List<QuestionnaireQuestionBean> questSourceList, boolean hasAnswerResult) {
      //  showLoading("数据解析中...", false);
        Observable.create(new ObservableOnSubscribe<QuestionnaireQuestionBean>() {
            @Override
            public void subscribe(ObservableEmitter<QuestionnaireQuestionBean> emitter) throws Exception {
                if (questionList == null) {
                    questionList = new ArrayList<>(questSourceList.size());
                } else {
                    questionList.clear();
                }
                // 如果当前不存在作答结果，那么创建新的作答结果
                if (!hasAnswerResult) {
                    idAnswerMap = new ArrayMap<>(questSourceList.size());
                }
                // 段落缓存列表
                ArrayList<QuestionnaireQuestionBean> materialList = null;
                QuestionnaireQuestionBean questionBean = null;
                // 执行数据转换操作，将段落说明提取出来组合成题目
                for (int index = 0; index < questSourceList.size(); index++) {
                    questionBean = questSourceList.get(index);
                    // 如果当前这个是段落说明
                    if ((questionBean.getQuestion_type() == QuestionnaireQuestionType.ParagraphDescription) && questionBean.getTitle() != null && !questionBean.getTitle().isEmpty()) {
                        if (materialList == null) {
                            materialList = new ArrayList<>(1);
                        }
                        materialList.add(questionBean);
                    }
                    // 否则将段落说明添加到题目中
                    else {
                        if (materialList != null) {
                            questionBean.setMaterialList(materialList);
                            materialList = null;
                        }
                        questionList.add(questionBean);
                        // 如果当前不存在作答结果，那么添加一个作答结果
                        if (!hasAnswerResult) {
                            QuestionnaireQuestionAnswerBean answerBean = null;
                            switch (questionBean.getQuestion_type()) {
                                // 单选题
                                case QuestionnaireQuestionType.SingleSelect:
                                    // 多选题
                                case QuestionnaireQuestionType.MultipleSelect:
                                    //评分题
                                case QuestionnaireQuestionType.ScoreType:
                                    answerBean = new QuestionnaireQuestionAnswerBean<List<QuestionnaireQuestionAnswerBean.SelectAnswerBean>>();
                                    answerBean.setContent(new ArrayList<QuestionnaireQuestionAnswerBean.SelectAnswerBean>(0));
                                    break;
                                // 开放型
                                case QuestionnaireQuestionType.OpenTopic:
                                    answerBean = new QuestionnaireQuestionAnswerBean<QuestionnaireQuestionAnswerBean.OpenTopicAnswerBean>();
                                    answerBean.setContent(new QuestionnaireQuestionAnswerBean.OpenTopicAnswerBean());
                                    break;
                                // 数值型
                                case QuestionnaireQuestionType.NumericalType:
                                    // 日期型
                                case QuestionnaireQuestionType.DateType:
                                    answerBean = new QuestionnaireQuestionAnswerBean<String>();
                                    answerBean.setContent(questionBean.getDefault_val());
                                    break;
                                // 级联下拉
                                case QuestionnaireQuestionType.CascadePullDown:
                                    answerBean = new QuestionnaireQuestionAnswerBean<List<QuestionnaireQuestionAnswerBean.CascadePullDownAnswerBean>>();
                                    answerBean.setContent(new ArrayList<QuestionnaireQuestionAnswerBean.CascadePullDownAnswerBean>(0));
                                    break;
                                default:
                                    answerBean =null;
                                    break;
                            }
                            if(answerBean!=null) {
                                // 设置好编号和类型
                                answerBean.setQuestion_id(questionBean.getId());
                                answerBean.setQuestion_type(questionBean.getQuestion_type());
                                // 执行添加操作
                                idAnswerMap.put(questionBean.getId(), answerBean);
                            }
                        }
                    }
                }
                // 如果段落说明不为空，那么新建立一个题目执行操作
                if (materialList != null) {
                    questionBean = new QuestionnaireQuestionBean();
                    questionBean.setQuestion_type(QuestionnaireQuestionType.ParagraphDescription);
                    questionBean.setMaterialList(materialList);
                    questionList.add(questionBean);
                }
                // emitter.onNext(null);
                emitter.onComplete();
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<QuestionnaireQuestionBean>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onComplete() {
                hidLoading();
                Message msg = Message.obtain();
                msg.what = QUESTION_PARSE_COMPLETE;
                msg.obj = hasAnswerResult;
                handler.sendMessage(msg);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(QuestionnaireQuestionBean questionBean) {
            }
        });
    }
    // 启动分线程执行答案数据解析操作
    @Override
    public void initQuestionAnswerMap(JSONArray jsonAnswerArray) {
        showLoading("数据解析中...", false);
        Observable.create(new ObservableOnSubscribe<QuestionnaireQuestionAnswerBean>() {
            @Override
            public void subscribe(ObservableEmitter<QuestionnaireQuestionAnswerBean> emitter) throws Exception {
                // 单选题、多选题类型
                Type selectType = new TypeToken<QuestionnaireQuestionAnswerBean<List<QuestionnaireQuestionAnswerBean.SelectAnswerBean>>>() {
                }.getType();
                // 开放型
                Type openTopicType = new TypeToken<QuestionnaireQuestionAnswerBean<QuestionnaireQuestionAnswerBean.OpenTopicAnswerBean>>() {
                }.getType();
                // 数值型、日期型
                Type valueType = new TypeToken<QuestionnaireQuestionAnswerBean<String>>() {
                }.getType();
                // 级联下拉格式
                Type cascadePullDownType = new TypeToken<QuestionnaireQuestionAnswerBean<List<QuestionnaireQuestionAnswerBean.CascadePullDownAnswerBean>>>() {
                }.getType();
                Gson gson = new Gson();
                JSONObject jsonObject = null;
                QuestionnaireQuestionAnswerBean answerBean = null;
                int count = jsonAnswerArray.length();
                if (idAnswerMap == null) {
                    idAnswerMap = new ArrayMap<>(count);
                }
                for (int i = 0; i < count; i++) {
                    jsonObject = jsonAnswerArray.optJSONObject(i);
                    int questionType = jsonObject.optInt("question_type");
                    Type resultType = null;
                    switch (questionType) {
                        // 单选题
                        case QuestionnaireQuestionType.SingleSelect:
                            // 多选题
                        case QuestionnaireQuestionType.MultipleSelect:
                            //评分题
                        case QuestionnaireQuestionType.ScoreType:
                            resultType = selectType;
                            break;
                        // 开放型
                        case QuestionnaireQuestionType.OpenTopic:
                            resultType = openTopicType;
                            break;
                        // 数值型
                        case QuestionnaireQuestionType.NumericalType:
                            // 日期型
                        case QuestionnaireQuestionType.DateType:
                            resultType = valueType;
                            break;
                        // 级联下拉
                        case QuestionnaireQuestionType.CascadePullDown:
                            resultType = cascadePullDownType;
                            break;
                        default:
                            break;
                    }
                    if (resultType != null) {
                        answerBean = gson.fromJson(jsonObject.toString(), resultType);
                        idAnswerMap.put(answerBean.getQuestion_id(), answerBean);
                    }
                }
                emitter.onComplete();
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<QuestionnaireQuestionAnswerBean>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onComplete() {
                hidLoading();
                Message msg = Message.obtain();
                msg.what = ANSWER_PARSE_COMPLETE;
                handler.sendMessage(msg);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(QuestionnaireQuestionAnswerBean answerBean) {
            }
        });
    }
    // 答题数据提交完毕之后的回调
    @Override
    public void submitStuQuestionnaireFinish(String answerId) {
        // 可以借助AnswerId再次执行操作
        if (!OffcnDataUtil.isEmpty(answerId)) {
            if(que_type==1){ //班级反馈
                setResult(RESULT_OK);
                finish();
            }else { //问卷提交
                showSubmitSuccessDialog(baseInfoBean.getPrompt());
            }
        }
    }
    // 获取一个上下文对象
    @Override
    public Context getContext() {
        return context;
    }
    // 异步生成作答结果并提交
    private void requestSubmitAnswerResult() {
        Collection<QuestionnaireQuestionAnswerBean> resultCollection = idAnswerMap.values();
        Gson gson = new Gson();
        String answerResult = gson.toJson(resultCollection);
        mPresenter.submitStuQuestionnaireContent(class_id, OffcnDataUtil.isEmpty(curriculum_id)?"0":curriculum_id, OffcnDataUtil.isEmpty(knobble_id)?"0":knobble_id, source_id, answerResult,extend_param,que_type);
    }
    // 准备适配器，开始展示数据
    private void initQuestionPageAdapter() {
        // 修改底部栏的状态
        llMainBottomBar.setVisibility(QuestionnaireStatus.Filling == questionnaireStatus ? View.VISIBLE : View.GONE);
        vBottomLine.setVisibility(QuestionnaireStatus.Filling == questionnaireStatus ? View.VISIBLE : View.GONE);
        // 准备设置适配器(先获取到最后一条数据是否是段落说明)
        boolean isLastMaterial = false;
        if (questionList.size() > 0) {
            QuestionnaireQuestionBean lastQuestion = questionList.get(questionList.size() - 1);
            isLastMaterial = QuestionnaireQuestionType.ParagraphDescription == lastQuestion.getQuestion_type();
        }
        mainAdapter = new StuQuestionnaireMainAdapter(getSupportFragmentManager(), questionList, isLastMaterial);
        vpMain.setAdapter(mainAdapter);
        vpMain.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
            @Override
            public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
            }
            @Override
            public void onPageSelected(int position) {
                StuQuestionnaireMainActivity.this.onPageSelected(position);
            }
            @Override
            public void onPageScrollStateChanged(int state) {
            }
        });
        // 默认选择第一个界面
        onPageSelected(0);
    }
    // 选择某个子界面时执行回调的方法
    private void onPageSelected(int position) {
        // 执行操作，告知当前Fragment是可见的，告知上一个可见的Fragment是不可见的了，如此便能够调动主界面执行操作了
        StuQuestionnaireEachFragment fragment = mainAdapter.getFragment(position);
        if (curShowFragment != null && curShowFragment != fragment) {
            curShowFragment.setShowStatus(false);
        }
        curShowFragment = fragment;
        curShowFragment.setShowStatus(true);
        // 如果当前是最后一道题，修改文案
        if (position == questionList.size() - 1) {
            tvNextQuestion.setText("提交");
        } else {
            tvNextQuestion.setText("下一题");
        }
        // 如果只有一道题的话，那么上一题直接不可见
        tvPreviousQuestion.setVisibility(position == 0 ? View.INVISIBLE : View.VISIBLE);
    }
    // 展示提交数据成功的对话框
    private void showSubmitSuccessDialog(String strTip) {
        if (submitSuccessDialog == null) {
            submitSuccessDialog = new StuQuestionnaireSubmitSuccessDialog(context);
            submitSuccessDialog.setOnFinishListener(new StuQuestionnaireSubmitSuccessDialog.OnFinishListener() {
                @Override
                public void OnFinish() {
                    // 发送消息通知列表已经完成了问卷的作答
                    EventBus.getDefault().post(new StuRefreshHwListEvent());
                    finish();
                }
            });
        }
        submitSuccessDialog.showDialog(strTip);
    }
    // 展示回退提示对话框
    private void showBackSpaceDialog() {
        if (backSpaceDialog == null) {
            backSpaceDialog = new StuServiceDialog();
        }
        // 显示对话框
        backSpaceDialog.showServiceDialog(context, "确定要退出吗？", "退出后不保存当前作答记录", "取消", "确定", new StuServiceDialog.OnClickListener() {
            @Override
            public void selected(boolean isSelected) {
                if (isSelected) {
                    finish();
                }
            }
        });
    }
    @Override
    public void onBackPressed() {
        // super.onBackPressed();
        ivBack.callOnClick();
    }
    /**
     * 添加一个图片的缓存
     *
     * @param key
     * @param url
     */
    @Override
    public void putPicture(String key, String url) {
        pictureCache.put(key, url);
    }
    /**
     * 获取一个图片的缓存
     *
     * @param key
     */
    @Override
    public String getPicture(String key) {
        if (pictureCache != null) return pictureCache.get(key);
        return "";
    }
    /**
     * 清除一个图片的缓存
     *
     * @param key
     */
    @Override
    public void removePicture(String key) {
        if (pictureCache != null) pictureCache.remove(key);
    }
    /**
     * 提交作答数据到结果中
     *
     * @param answerBean
     */
    @Override
    public void putAnswerResult(QuestionnaireQuestionAnswerBean answerBean) {
        if (answerBean != null) {
            idAnswerMap.put(answerBean.getQuestion_id(), answerBean);
        }
    }
    /**
     * 从主界面中请求获取到作答结果
     *
     * @param questionId
     * @return
     */
    @Override
    public QuestionnaireQuestionAnswerBean getAnswerResult(int questionId) {
        try {
-            idAnswerMap = new ArrayMap<>(questionList.size());
+            if(idAnswerMap==null){
-            return idAnswerMap.get(questionId);
+                idAnswerMap = new ArrayMap<>(questionList.size());
-        }catch (NullPointerException e){
+            }else{
+                return idAnswerMap.get(questionId);
-        }
+            }
-       return null;
+        } catch (NullPointerException e) {
-    }
+        }
-    /**
+       return null;
-     * 设置问卷主页面底部的下一题属性
+    }
-     *
-     * @param nextEnable 下一题是否可以启用
+    /**
-     */
+     * 设置问卷主页面底部的下一题属性
-    @Override
+     *
-    public void setNextBtnStatus(boolean nextEnable) {
+     * @param nextEnable 下一题是否可以启用
-        if (questionnaireStatus == QuestionnaireStatus.Filling) {
+     */
-            this.nextBtnStatus = nextEnable;
+    @Override
-            tvNextQuestion.setBackgroundResource(nextBtnStatus ? nextEnableRes : nextDisableRes);
+    public void setNextBtnStatus(boolean nextEnable) {
-        }
+        if (questionnaireStatus == QuestionnaireStatus.Filling) {
-    }
+            this.nextBtnStatus = nextEnable;
+            tvNextQuestion.setBackgroundResource(nextBtnStatus ? nextEnableRes : nextDisableRes);
-    /**
+        }
-     * 获取到问卷状态
+    }
-     *
-     * @return
+    /**
-     */
+     * 获取到问卷状态
-    @Override
+     *
-    public QuestionnaireStatus getQuestionnaireStatus() {
+     * @return
-        return questionnaireStatus;
+     */
-    }
+    @Override
+    public QuestionnaireStatus getQuestionnaireStatus() {
-    /**
+        return questionnaireStatus;
-     * 展示软键盘
+    }
-     * @param view
-     */
+    /**
-    @Override
+     * 展示软键盘
-    public void showSoftKeyboard(View view) {
+     * @param view
-        // 底部栏的隐藏需要立即执行
+     */
-        llMainBottomBar.setVisibility(View.GONE);
+    @Override
-        vBottomLine.setVisibility(View.GONE);
+    public void showSoftKeyboard(View view) {
-        // 延迟隐藏底部栏，防止闪动
+        // 底部栏的隐藏需要立即执行
-        llMainBottomBar.postDelayed(new Runnable() {
+        llMainBottomBar.setVisibility(View.GONE);
-            @Override
+        vBottomLine.setVisibility(View.GONE);
-            public void run() {
+        // 延迟隐藏底部栏，防止闪动
-                OffcnDeviceUtil.showSoftKeyboard(view);
+        llMainBottomBar.postDelayed(new Runnable() {
-                llMainBottomBar.removeCallbacks(this);
+            @Override
-            }
+            public void run() {
-        }, 16);
+                OffcnDeviceUtil.showSoftKeyboard(view);
-    }
+                llMainBottomBar.removeCallbacks(this);
+            }
-    /**
+        }, 16);
-     * 隐藏软键盘
+    }
-     */
-    @Override
+    /**
-    public void hideSoftKeyboard() {
+     * 隐藏软键盘
-        // 延迟隐藏底部栏，防止闪动
+     */
-        OffcnDeviceUtil.hideSoftKeyboard(context);
+    @Override
-    }
+    public void hideSoftKeyboard() {
+        // 延迟隐藏底部栏，防止闪动
-    /**
+        OffcnDeviceUtil.hideSoftKeyboard(context);
-     * 主要是添加图片的ActivityResult事件
+    }
-     *
-     * @param requestCode
+    /**
-     * @param resultCode
+     * 主要是添加图片的ActivityResult事件
-     * @param data
+     *
-     */
+     * @param requestCode
-    @Override
+     * @param resultCode
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+     * @param data
-        super.onActivityResult(requestCode, resultCode, data);
+     */
-        // 执行数据的判定操作，部分数据需要Activity配合发布
+    @Override
-        if (resultCode == Activity.RESULT_OK) {
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-            if (curShowFragment != null) {
+        super.onActivityResult(requestCode, resultCode, data);
-                curShowFragment.onActivityResult(requestCode, resultCode, data);
+        // 执行数据的判定操作，部分数据需要Activity配合发布
-            }
+        if (resultCode == Activity.RESULT_OK) {
-        }
+            if (curShowFragment != null) {
-    }
+                curShowFragment.onActivityResult(requestCode, resultCode, data);
+            }
-    @Override
+        }
-    public void showLoading(String msg, boolean cancel) {
+    }
-        loadingDialog.showDialog(msg, cancel);
-    }
+    @Override
+    public void showLoading(String msg, boolean cancel) {
-    @Override
+        loadingDialog.showDialog(msg, cancel);
-    public void hidLoading() {
+    }
-        loadingDialog.dismissDialog();
-    }
+    @Override
+    public void hidLoading() {
-    @Override
+        loadingDialog.dismissDialog();
-    public void showLoading() {
+    }
-        loadingDialog.showDialog("玩命加载中", false);
-    }
+    @Override
+    public void showLoading() {
-    @Override
+        loadingDialog.showDialog("玩命加载中", false);
-    public void hideLoading() {
+    }
-        loadingDialog.dismissDialog();
-    }
+    @Override
+    public void hideLoading() {
-    @Override
+        loadingDialog.dismissDialog();
-    public void showMessage(@NonNull String message) {
+    }
-        checkNotNull(message);
-        OffcnUtils.snackbarText(message);
+    @Override
-    }
+    public void showMessage(@NonNull String message) {
+        checkNotNull(message);
-    @Override
+        OffcnUtils.snackbarText(message);
-    public void launchActivity(@NonNull Intent intent) {
+    }
-        checkNotNull(intent);
-        OffcnUtils.startActivity(intent);
+    @Override
-    }
+    public void launchActivity(@NonNull Intent intent) {
+        checkNotNull(intent);
-    @Override
+        OffcnUtils.startActivity(intent);
-    public void killMyself() {
+    }
-        finish();
-    }
+    @Override
+    public void killMyself() {
-    @Override
+        finish();
-    public void onDestroy() {
+    }
-        // 关闭加载中的对话框
-        if (loadingDialog != null) {
+    @Override
-            loadingDialog.dismissDialog();
+    public void onDestroy() {
-            loadingDialog = null;
+        // 关闭加载中的对话框
-        }
+        if (loadingDialog != null) {
-        super.onDestroy();
+            loadingDialog.dismissDialog();
-    }
+            loadingDialog = null;
-}
+        }
+        super.onDestroy();
+    }
+}