public void removeBeanContextServicesListener(
        BeanContextServicesListener p0) {
    return;
}

public void addBeanContextServicesListener(
        BeanContextServicesListener p0) {
    return;
}

public static BeanContextServicesListener publicGetChildBeanContextServicesListener(
        Object child) {
    return getChildBeanContextServicesListener(child);
}

public void testGetChildBeanContextServicesListener_Nullparam() {
    BeanContextServicesListener result = MockBeanContextServicesSupport
            .publicGetChildBeanContextServicesListener(null);
    assertNull(result);
}

public void testGetChildBeanContextServicesListener_Is() {
    MockBeanContextServicesListener l = new MockBeanContextServicesListener();
    BeanContextServicesListener result = MockBeanContextServicesSupport
            .publicGetChildBeanContextServicesListener(l);
    assertSame(l,result);
}

public void testGetChildBeanContextServicesListener_IsNot() {
    BeanContextServicesListener result = MockBeanContextServicesSupport
            .publicGetChildBeanContextServicesListener("is not");
    assertNull(result);
}

public void removeBeanContextServicesListener(
        BeanContextServicesListener bcsl) {
    // Auto-generated method stub

}

public static BeanContextServicesListener publicGetChildBeanContextServicesListener(
        Object child) {
    return getChildBeanContextServicesListener(child);
}

public void testGetChildBeanContextServicesListener_Nullparam() {
    BeanContextServicesListener result = MockBeanContextServicesSupport
            .publicGetChildBeanContextServicesListener(null);
    assertNull(result);
}

public void testGetChildBeanContextServicesListener_Is() {
    MockBeanContextServicesListener l = new MockBeanContextServicesListener();
    BeanContextServicesListener result = MockBeanContextServicesSupport
            .publicGetChildBeanContextServicesListener(l);
    assertSame(l,result);
}

public void testGetChildBeanContextServicesListener_IsNot() {
    BeanContextServicesListener result = MockBeanContextServicesSupport
            .publicGetChildBeanContextServicesListener("is not");
    assertNull(result);
}

public void removeBeanContextServicesListener(
        BeanContextServicesListener bcsl) {
    // Auto-generated method stub

}

public void removeBeanContextServicesListener(
        BeanContextServicesListener p0) {
    return;
}

public void addBeanContextServicesListener(
        BeanContextServicesListener p0) {
    return;
}

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code>
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code>
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code>
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code>
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a {@code BeanContextServicesListener} to this BeanContext
 * @param bcsl the {@code BeanContextServicesListener} to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a {@code BeanContextServicesListener}
 * from this {@code BeanContext}
 * @param bcsl the {@code BeanContextServicesListener}
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a {@code BeanContextServicesListener} to this BeanContext
 * @param bcsl the {@code BeanContextServicesListener} to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a {@code BeanContextServicesListener}
 * from this {@code BeanContext}
 * @param bcsl the {@code BeanContextServicesListener}
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code>
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code>
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code>
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code>
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code>
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code>
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code> 
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code> 
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code>
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code>
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Removes a <code>BeanContextServicesListener</code>
 * from this <code>BeanContext</code>
 * @param bcsl the <code>BeanContextServicesListener</code>
 * to remove from this context
 */
void removeBeanContextServicesListener(BeanContextServicesListener bcsl);

/**
 * Adds a <code>BeanContextServicesListener</code> to this BeanContext
 * @param bcsl the <code>BeanContextServicesListener</code> to add
 */
void addBeanContextServicesListener(BeanContextServicesListener bcsl);

private void showLoadingDialog() {
    dismisLoadingDialog();
    this.loadingDialog = new LoadingDialog((Context) this,2131100006);
    this.loadingDialog.show();
    this.loadingDialog.setonCancelListener(new OnCancelListener(this) {
        final /* synthetic */ ChinaMobileWebPayActivity this$0;

        {
            if (HotFix.PREVENT_VERIFY) {
                System.out.println(VerifyLoad.class);
            }
            this.this$0 = this$0;
        }

        public void onCancel(DialogInterface dialog) {
            this.this$0.showFailedDialog();
        }
    });
}

private void receiveMessages(int i) {
  if (checkState == CheckState.EXIST) {
    changeState(State.RECEIVEING);

    slotIndex = i;
    String address = mainActivity.getSavedValue("REMO_DEVICE_ADDRESS");
    remoController.recevieMessages(address);
    receiveDialog = new ProgressDialog(mainActivity);
    receiveDialog.setButton(DialogInterface.BUTTON_NEGATIVE,"Cancel",new DialogInterface.OnClickListener() {
      @Override
      public void onClick(DialogInterface dialog,int which) {
        receiveDialog.cancel();
      }
    });
    receiveDialog.setonCancelListener(new OnCancelListener() {
      @Override
      public void onCancel(DialogInterface dialogInterface) {
        Log.d(TAG,"onCancel: ");
        changeState(State.IDLE);
        remoController.cancelReceiveMessages();
      }
    });
    receiveDialog.setMessage(getString(R.string.remo_receive_dialog));
    receiveDialog.show();
  }
}

public MQConfirmDialog(Activity activity,String title,String content,OnDialogCallback
        onDialogCallback) {
    super(activity,R.style.MQDialog);
    getwindow().setLayout(-1,-2);
    setContentView(R.layout.mq_dialog_confirm);
    this.mTitleTv = (TextView) findViewById(R.id.tv_comfirm_title);
    this.mContentTv = (TextView) findViewById(R.id.tv_comfirm_content);
    findViewById(R.id.tv_confirm_cancel).setonClickListener(this);
    findViewById(R.id.tv_confirm_confirm).setonClickListener(this);
    setonCancelListener(new OnCancelListener() {
        public void onCancel(DialogInterface dialog) {
            MQConfirmDialog.this.mOnDialogCallback.onClickCancel();
        }
    });
    setCanceledOnTouchOutside(true);
    setCancelable(true);
    this.mOnDialogCallback = onDialogCallback;
    this.mTitleTv.setText(title);
    this.mContentTv.setText(content);
}

@Deprecated
public static EasyProgressDialog showProgressDialog(Context context,String message,boolean canCancelable,OnCancelListener listener) {

    if (progressDialog == null) {
        progressDialog = new EasyProgressDialog(context,message);
    } else if (progressDialog.getContext() != context) {
        // maybe existing dialog is running in a destroyed activity cotext
        // we should recreate one
        LogUtil.e("dialog","there is a leaked window here,orign context: "
                + progressDialog.getContext() + " Now: " + context);
        dismissprogressDialog();
        progressDialog = new EasyProgressDialog(context,message);
    }

    progressDialog.setCancelable(canCancelable);
    progressDialog.setonCancelListener(listener);

    progressDialog.show();

    return progressDialog;
}

@Override
public void onError(BarcodeScanView scanView,int type) {
    // mBarcodeScanView.releaseAsync();
    if (type == BarcodeScanView.PREPARE_ERROR_TYPE
            || type == BarcodeScanView.CONfig_FLASH_LIGHT_ERROR_TYPE) {
        if (mAlertDialog == null) {
            mAlertDialog = DialogUtil.createCameraAlertDialog(BarcodeScanActivity.this,R.string.hint_information,R.string.camera_open_problem,R.string.ok);
            mAlertDialog.setonCancelListener(new OnCancelListener() {
                @Override
                public void onCancel(DialogInterface dialog) {
                    finish();
                }
            });
        }
        mAlertDialog.show();
    }
}

public static AlertDialog showAlert(final Context context,final String title,final String msg,final View view,final DialogInterface.OnClickListener lOk,final DialogInterface.OnClickListener lCancel) {
    if (context instanceof Activity && ((Activity) context).isFinishing()) {
        return null;
    }

    final Builder builder = new AlertDialog.Builder(context);
    builder.setTitle(title);
    builder.setMessage(msg);
    builder.setView(view);
    builder.setPositiveButton(R.string.app_ok,lOk);
    builder.setNegativeButton(R.string.app_cancel,lCancel);
    // builder.setCancelable(true);
    builder.setonCancelListener(new DialogInterface.OnCancelListener() {

        @Override
        public void onCancel(DialogInterface dialog) {
            if (lCancel != null) {
                lCancel.onClick(dialog,0);
            }
        }
    });
    final AlertDialog alert = builder.create();
    alert.show();
    return alert;
}

@Deprecated
public static EasyProgressDialog showProgressDialog(Context context,message);
    }

    progressDialog.setCancelable(canCancelable);
    progressDialog.setonCancelListener(listener);

    progressDialog.show();

    return progressDialog;
}

/**
 * 显示可取消的进度对话框
 * 
 * @param msg
 *            消息
 */
public void showProgressDialog(final String msg,final boolean cancelable,final OnCancelListener cancelListener,final boolean showProgressBar) {
    dismissprogressDialog();

    mActivity.runOnUiThread(new Runnable() {

        @Override
        public void run() {
            if (mActivity == null || mActivity.isFinishing()) {
                return;
            }

            mAlertDialog = new GenericProgressDialog(mActivity);
            mAlertDialog.setMessage(msg);
            ((GenericProgressDialog) mAlertDialog).setProgressVisiable(showProgressBar);
            mAlertDialog.setCancelable(cancelable);
            mAlertDialog.setonCancelListener(cancelListener);

            mAlertDialog.show();

            mAlertDialog.setCanceledOnTouchOutside(false);
        }
    });
}

public static AlertDialog createTheDialog(Context context,int titleId,OnCancelListener listener,OnCheckedchangelistener checkedchangelistener,android.widget.CompoundButton.OnCheckedchangelistener checkBoxchangelistener){
    LayoutInflater inflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    View view = inflater.inflate(R.layout.has_same_file_check,null);
    AlertDialog dialog = new AlertDialog.Builder(context)
    .setView(view)
       .setTitle(titleId)
       .setonCancelListener(listener)
       .create();
    RadioGroup rg = (RadioGroup)view.findViewById(R.id.whichOperation);
    rg.setonCheckedchangelistener(checkedchangelistener);
    CheckBox cb = (CheckBox)view.findViewById(R.id.doitasSame);
    cb.setonCheckedchangelistener(checkBoxchangelistener);
    return dialog;
}

/**
 * 显示可取消的进度对话框
 * 
 * @param msg
 *            消息
 */
public void showProgressDialog(final String msg,final boolean showProgressBar) {
    dismissprogressDialog();

    mActivity.runOnUiThread(new Runnable() {

        @Override
        public void run() {
            if (mActivity == null || mActivity.isFinishing()) {
                return;
            }

            mAlertDialog = new GenericProgressDialog(mActivity);
            mAlertDialog.setMessage(msg);
            ((GenericProgressDialog) mAlertDialog).setProgressVisiable(showProgressBar);
            mAlertDialog.setCancelable(cancelable);
            mAlertDialog.setonCancelListener(cancelListener);

            mAlertDialog.show();

            mAlertDialog.setCanceledOnTouchOutside(false);
        }
    });
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    // Todo Auto-generated method stub
    String message = getArguments().getString("message");

    ProgressDialog pd = new ProgressDialog(getActivity());      
    pd.setIndeterminate(true);
    pd.setonCancelListener( new OnCancelListener() {
        @Override
        public void onCancel(DialogInterface dialog) {
            //getActivity().finish();               
        } } );      

    pd.setMessage(message);

    //this.setStyle(STYLE_norMAL,ThemeUtil.getAlertTheme(this.getActivity()));

    return pd;


}

private void reload()
{
    relayout_alert.setVisibility(View.GONE);
    if (pageIndex == 0)
    {
        progressDialog(R.string.loading_label);
        dialog.setonCancelListener(new OnCancelListener()
        {

            @Override
            public void onCancel(DialogInterface arg0)
            {
                finish();
            }
        });
    }
    videoListViewHandler.getRecordVideoList(date,iCam,pageIndex,isAllCamera);
}

/**
 * 
 * @Title showSheet
 * @Description Todo(这里用一句话描述这个方法的作用)
 * @param mContext
 *            上下文环境
 * @param actionSheetConfig
 *            ActionSheet配置项
 * @param actionSheetItemSelected
 *            ActionSheet Item选中监听
 * @param cancelListener
 *            取消按钮的监听,无需监听可传null
 * @return Dialog 返回类型
 */
@SuppressLint("NewApi")
public void show(final Activity activity,ActionSheetConfig actionSheetConfig,final OnActionSheetItemSelected actionSheetItemSelected,OnCancelListener cancelListener) {
    switch (actionSheetConfig.actionsheetStyle) {

    case ACTIONSHEET_IOS:
        new ActionSheet4IOS().show(activity,actionSheetConfig,actionSheetItemSelected,cancelListener);

        break;
    case ACTIONSHEET_WECHAT:
        new ActionSheet4WeChat().show(activity,cancelListener);
        break;
    default:
        new ActionSheet4WeChat().show(activity,cancelListener);
    }
}

private void showProgress() {
    if (loadingDialog == null) {
        if (splash > 0) {
            Log.i("SplashActivity Showing splash");
            setContentView(splash);
        } else {
            Log.i("SplashActivity Showing progress");
            loadingDialog = ProgressDialog.show(this,null,"Starting...",true,true);
            loadingDialog.setCanceledOnTouchOutside(false);
            loadingDialog.setonCancelListener(new OnCancelListener() {
                public void onCancel(DialogInterface dialog) {
                    dialogCancelled = true;
                    finish();
                }
            });
        }
    }
}

private void startProgressBar() {
    if (mDlgProgress == null) {
        mDlgProgress = ProgressDialog.show(this,"",getResources().getString(R.string.add_tip_todo_activity_progress_message));
        mDlgProgress.setCancelable(true);
        mDlgProgress.setonCancelListener(new OnCancelListener() {
            @Override
            public void onCancel(DialogInterface dialog) {
                Log.e(TAG,"User cancelled add tip.");
                mStateHolder.cancelTasks();
            }
        });
    }
    mDlgProgress.show();
    setProgressBarIndeterminateVisibility(true);
}

@Override
protected Dialog onCreateDialog(int id) {
    switch (id) {
        case DIALOG_CHECKIN_RESULT:
            // When the user cancels the dialog (by hitting the 'back' key),we
            // finish this activity. We don't listen to ondismiss() for this
            // action,because a device rotation will fire ondismiss(),and our
            // dialog would not be re-displayed after the rotation is complete.
            CheckinResultDialog dlg = new CheckinResultDialog(
                this,mStateHolder.getCheckinResult(),((Foursquared)getApplication()));
            dlg.setonCancelListener(new OnCancelListener() {
                @Override
                public void onCancel(DialogInterface dialog) {
                    removeDialog(DIALOG_CHECKIN_RESULT);
                    setResult(Activity.RESULT_OK);
                    finish();
                }
            });
            return dlg;
    }
    return null;
}

private void startProgressBar() {
    if (mDlgProgress == null) {
        mDlgProgress = ProgressDialog.show(this,"User cancelled add todo.");
                mStateHolder.cancelTasks();
            }
        });
    }
    mDlgProgress.show();
    setProgressBarIndeterminateVisibility(true);
}

public static void show(Activity activity,boolean isCancelable,OnCancelListener listener) {

    mProgressDialog = new ProgressDialog(activity);
    mProgressDialog.setProgressstyle(ProgressDialog.STYLE_SPINNER);
    mProgressDialog.setIndeterminate(true);
    mProgressDialog.getwindow().setGravity(Gravity.CENTER_VERTICAL);
    mProgressDialog.setCancelable(isCancelable);

    if (AppUtil.isNotEmpty(title)) {
        mProgressDialog.setMessage(title);
    }

    if (null != listener) {
        mProgressDialog.setonCancelListener(listener);
    }

    if (mProgressDialog.isShowing()) {
        mProgressDialog.dismiss();
    }
    mProgressDialog.show();
}

/**手动点击返回键取消弹出窗口，会发送该事件；接着会发送OndismissListener事件**/
public synchronized static void setonCancelListener(OnCancelListener l) {
    if(mOnCancelListener == l) return;
    final OnCancelListener oldListnener = mOnCancelListener;
    mOnCancelListener = l;
    if(oldListnener != null) {
        final MyDialog dialog = MyDialog.get();
        if(dialog != null) {
            if(mUiThread != Thread.currentThread()) {
                if(mHandler != null) mHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        oldListnener.onCancel(dialog);
                    }
                });
            }else {
                oldListnener.onCancel(dialog);
            }
        }
    }
}

public static void zza(Activity paramActivity,DialogInterface.OnCancelListener paramOnCancelListener,String paramString,Dialog paramDialog)
{
  if ((paramActivity instanceof FragmentActivity))
  {
    android.support.v4.app.FragmentManager localFragmentManager1 = ((FragmentActivity)paramActivity).getSupportFragmentManager();
    SupportErrorDialogFragment.newInstance(paramDialog,paramOnCancelListener).show(localFragmentManager1,paramString);
    return;
  }
  if (zzq.zzdC(11))
  {
    android.app.FragmentManager localFragmentManager = paramActivity.getFragmentManager();
    ErrorDialogFragment.newInstance(paramDialog,paramOnCancelListener).show(localFragmentManager,paramString);
    return;
  }
  throw new RuntimeException("This Activity does not support Fragments.");
}

public final void onProviderInstallFailed$10b55c15(int paramInt)
{
  sendAnalyticsBackgroundEvent$255f295(paramInt);
  GoogleApiAvailability.getInstance();
  if (GoogleApiAvailability.isUserResolvableError(paramInt))
  {
    GooglePlayServicesUtil.showErrorDialogFragment(paramInt,getActivity(),this,6000,new DialogInterface.OnCancelListener()
    {
      public final void onCancel(DialogInterface paramAnonymousDialogInterface)
      {
        AnalyticsUtil.createAndSendClickEvent(RedirectFragment.this,1636,1622);
        RedirectFragment.this.onProviderInstallerNotAvailable();
      }
    });
    AnalyticsUtil.createAndSendImpressionEvent(this,1636);
    return;
  }
  onProviderInstallerNotAvailable();
}

@Override
protected void onPreExecute() {
    super.onPreExecute();
    if (context != null) {
        progressDialog = new ProgressDialog(context);
        progressDialog.setMessage(context.getResources().getString(
                R.string.loading_message));
        progressDialog.setIndeterminate(false);
        progressDialog.setProgressstyle(ProgressDialog.STYLE_SPINNER);
        progressDialog.setCancelable(true);
        progressDialog.setonCancelListener(new OnCancelListener() {

            @Override
            public void onCancel(DialogInterface arg0) {
                progressDialog.dismiss();
            }
        });

        progressDialog.show();
    }
}

public static AlertDialog showAlert(final Context context,0);
            }
        }
    });
    final AlertDialog alert = builder.create();
    alert.show();
    return alert;
}

private void showProgress() {
    if (state == states.LOAD_START) {
        state = states.LOAD_PROGRESS;
    }

    if (progressDialog == null || !progressDialog.isShowing()) {
        progressDialog = ProgressDialog.show(this,getString(R.string.romanblack_html_loading),true);
        progressDialog.setCancelable(false);
        progressDialog.setonCancelListener(new OnCancelListener() {
            @Override
            public void onCancel(DialogInterface dialog) {
                handler.sendEmptyMessage(LOADING_ABORTED);
            }
        });
    }
}

private void prepareAndShowProgressDialog() {
    this.progressDialog = new ProgressDialog(this.context);
    // progressDialog.setMessage("正在初始化公共数据...");
    if (this.loadingString != null) {
        this.showProgressstring(this.loadingString);
    }
    this.progressDialog.setCancelable(this.isCancleAble);
    if (this.isCancleAble) {
        progressDialog.setonCancelListener(new OnCancelListener() {

            @Override
            public void onCancel(DialogInterface dialog) {
                BasicAsyncTask.this.cancel();
            }
        });
    }
    progressDialog.show();
}

public static void showCancelabletoast(Context context,String message) {
    // TextView tv = new TextView(context);
    // tv.setText(message);
    // mCancelableDialog = new AlertDialog.Builder(context).setView(tv).setCancelable(true).create();
    mCancelableDialog = new AlertDialog.Builder(context).setMessage(message).setCancelable(true).create();
    mCancelableDialog.setonCancelListener(new OnCancelListener() {
        @Override
        public void onCancel(DialogInterface dialog) {
            if (mTimer != null) {
                mTimer.cancel();
            }
        }
    });
    mCancelableDialog.show();

    if (mTimer != null) {
        mTimer.start();
    }

}

@Override
protected void onPreExecute() {
    // Todo Auto-generated method stub
    // super.onPreExecute();
    if (mDialog != null) {
        mDialog.setTitle("正在解压文件");
        mDialog.setMessage(mInput.getName());
        mDialog.setProgressstyle(ProgressDialog.STYLE_HORIZONTAL);
        mDialog.setonCancelListener(new OnCancelListener() {

            @Override
            public void onCancel(DialogInterface dialog) {
                // Todo Auto-generated method stub
                cancel(false);
            }
        });
        mDialog.show();
    }
}

private void showDialog() {
    BookDownloadDialog mDialog = new BookDownloadDialog(this,false);

    mDialog.setMessage("正在下载");
    mDialog.setProgressstyle(ProgressDialog.STYLE_HORIZONTAL);
    mDialog.setonCancelListener(new OnCancelListener() {

        @Override
        public void onCancel(DialogInterface dialog) {
            // Todo Auto-generated method stub
            // cancel(true);
        }
    });
    mDialog.show();

    mDialog.setMax(100 * 1024 * 1024);
    mDialog.setProgress(65 * 1024 * 1024);
}

public static void showMessageDialog(String title,Activity activity,final Handler handler)
{
    LayoutInflater inflater = LayoutInflater.from(activity);
       View view = inflater.inflate(R.layout.prompter_message,null);
       AlertDialog.Builder builder = new AlertDialog.Builder(activity);
    TextView titleText = (TextView)view.findViewById(R.id.titleText);
    titleText.setText(title);
    TextView messageText = (TextView)view.findViewById(R.id.messageText);
    messageText.setText(message);
       builder.setView(view);
       if(handler != null)
       {
        builder.setonCancelListener(new OnCancelListener() {
            public void onCancel(final DialogInterface dialog) {
                handler.sendEmptyMessage(0);
            }
        });
       }
       builder.create();
       builder.show();
}

@Deprecated
public static EasyProgressDialog showProgressDialog(Context context,message);
    }

    progressDialog.setCancelable(canCancelable);
    progressDialog.setonCancelListener(listener);

    progressDialog.show();

    return progressDialog;
}

public void showWait(OnCancelListener cancelListener) {
    if (mContext.isFinishing()) {
        return;
    }
    if (dismissWiat()) {
        mWaitPopup = new CustomDialog(mContext);
        LayoutInflater inflater = (LayoutInflater) mContext.getApplicationContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        ViewGroup layout = (ViewGroup) inflater.inflate(R.layout.popup_wait,null);
        mWaitPopup.setLayout(layout);
    }
    if (cancelListener != null) {
        mWaitPopup.setCancelable(true);
        mWaitPopup.setonCancelListener(cancelListener);
    } else {
        mWaitPopup.setCancelable(false);
        mWaitPopup.setonCancelListener(null);
    }
    mWaitPopup.findViewById(R.id.waitpopup_container).setVisibility(View.VISIBLE);
    mWaitPopup.show();
}

public static AlertDialog showAlert(final Context context,0);
            }
        }
    });
    final AlertDialog alert = builder.create();
    alert.show();
    return alert;
}

private void showProgress() {
    if (loadingDialog == null) {
        if (splash > 0) {
            Log.i("Showing splash");
            setContentView(splash);
        } else {
            Log.i("Showing progress");
            loadingDialog = ProgressDialog.show(this,true);
            loadingDialog.setCanceledOnTouchOutside(false);
            loadingDialog.setonCancelListener(new OnCancelListener() {
                public void onCancel(DialogInterface dialog) {
                    dialogCancelled = true;
                    finish();
                }
            });
        }
    }
}

/**
 * 显示刷新弹出框有背景层
 */
public void showLoadDialog() {

    final AbLoadDialogFragment mDialogFragment = AbDialogUtil
            .showLoadDialog(this,R.drawable.ic_load,"正在查询,请稍候");
    mDialogFragment.setAbDialogonLoadListener(new AbDialogonLoadListener() {

        @Override
        public void onLoad() {
            // 下载网络数据
            downRSS(mDialogFragment);
        }

    });
    // 取消的监听
    mDialogFragment.setonCancelListener(new OnCancelListener() {

        @Override
        public void onCancel(DialogInterface dialog) {
            AbToastUtil.showToast(DialogActivity.this,"Load框被取消");
        }

    });
}

/**
 * 显示加载弹出框无背景层
 */
public void showLoadPanel() {

    final AbLoadDialogFragment mDialogFragment = AbDialogUtil
            .showLoadPanel(this,"Load框被取消");
        }

    });
}

/**
 * 显示刷新弹出框有背景层
 */
public void showRefreshDialog() {
    // 显示重新刷新的框
    final AbRefreshDialogFragment mDialogFragment = AbDialogUtil
            .showRefreshDialog(this,R.drawable.ic_refresh,"请求出错，请重试");
    mDialogFragment.setAbDialogonLoadListener(new AbDialogonLoadListener() {

        @Override
        public void onLoad() {
            // 下载网络数据
            downRSS(mDialogFragment);
        }

    });
    // 取消的监听
    mDialogFragment.setonCancelListener(new OnCancelListener() {

        @Override
        public void onCancel(DialogInterface dialog) {
            AbToastUtil.showToast(DialogActivity.this,"refresh框被取消");
        }

    });
}

/**
 * 显示刷新弹出框无背景层
 */
public void showRefreshPanel() {
    // 显示重新刷新的框
    final AbRefreshDialogFragment mDialogFragment = AbDialogUtil
            .showRefreshPanel(this,"请求出错，请重试");
    mDialogFragment.setAbDialogonLoadListener(new AbDialogonLoadListener() {

        @Override
        public void onLoad() {
            // 下载网络数据
            downRSS(mDialogFragment);
        }

    });

    mDialogFragment.setonCancelListener(new OnCancelListener() {

        @Override
        public void onCancel(DialogInterface dialog) {
            AbToastUtil.showToast(DialogActivity.this,"load框被取消");
        }

    });
}

void call(String target) {
    if (!Receiver.engine(this).call(target,true)) {
        new AlertDialog.Builder(this)
        .setMessage(R.string.notfast)
        .setTitle(R.string.app_name)
        .setIcon(R.drawable.icon22)
        .setCancelable(true)
        .setonCancelListener(new OnCancelListener() {
            public void onCancel(DialogInterface dialog) {
                finish();
            }
        })
        .show();
    } else
        finish();
}

private void showProgress() {
    if (loadingDialog == null) {
        if (splash > 0) {
            Log.i("SplashActivity Showing splash");
            setContentView(splash);
        } else {
            Log.i("SplashActivity Showing progress");
            loadingDialog = ProgressDialog.show(this,true);
            loadingDialog.setCanceledOnTouchOutside(false);
            loadingDialog.setonCancelListener(new OnCancelListener() {
                public void onCancel(DialogInterface dialog) {
                    dialogCancelled = true;
                    finish();
                }
            });
        }
    }
}

@Override
public void onGetSentenceSuggestions(SentenceSuggestionsInfo[] results) {
   try {
       final List<String> sb = new ArrayList<>();
       for (int i = 0; i < results.length; ++i) {
           final SentenceSuggestionsInfo ssi = results[i];

           for (int j = 0; j < ssi.getSuggestionsCount(); ++j) {
               dumpSuggestionsInfoInternal(
                       sb,ssi.getSuggestionsInfoAt(j),ssi.getoffsetAt(j),ssi.getLengthAt(j));
           }
       }

       setSuggestions(sb,true,true);
   }
   catch(Exception e){}

}

/**
 * Callback for {@link SpellCheckerSession#getSentenceSuggestions(TextInfo[],int)}
 * @param results an array of {@link SentenceSuggestionsInfo}s.
 * These results are suggestions for {@link TextInfo}s
 * queried by {@link SpellCheckerSession#getSentenceSuggestions(TextInfo[],int)}.
 */
@Override
public void onGetSentenceSuggestions(final SentenceSuggestionsInfo[] arg0) {
    if (!isSentenceSpellCheckSupported()) {
        Log.e(TAG,"Sentence spell check is not supported on this platform,"
                + "but accidentially called.");
        return;
    }
    Log.d(TAG,"onGetSentenceSuggestions");
    final StringBuilder sb = new StringBuilder();
    for (int i = 0; i < arg0.length; ++i) {
        final SentenceSuggestionsInfo ssi = arg0[i];
        for (int j = 0; j < ssi.getSuggestionsCount(); ++j) {
            dumpSuggestionsInfoInternal(
                    sb,ssi.getLengthAt(j));
        }
    }
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            mMainView.append(sb.toString());
        }
    });
}

@Override
public SentenceSuggestionsInfo[] onGetSentenceSuggestionsMultiple(TextInfo[] textInfos,int suggestionsLimit) {
    final SentenceSuggestionsInfo[] retval = splitAndSuggest(textInfos,suggestionsLimit);
    if (retval == null || retval.length != textInfos.length) {
        return retval;
    }
    for (int i = 0; i < retval.length; ++i) {
        final SentenceSuggestionsInfo tempSsi =
                fixWronglyInvalidatedWordWithSingleQuote(textInfos[i],retval[i]);
        if (tempSsi != null) {
            retval[i] = tempSsi;
        }
    }
    return retval;
}

/**
 * Checks for typos and sends results back to native through a JNI call.
 * @param results Results returned by the Android spellchecker.
 */
@Override
public void onGetSentenceSuggestions(SentenceSuggestionsInfo[] results) {
    ArrayList<Integer> offsets = new ArrayList<Integer>();
    ArrayList<Integer> lengths = new ArrayList<Integer>();

    for (SentenceSuggestionsInfo result : results) {
        for (int i = 0; i < result.getSuggestionsCount(); i++) {
            // If a word looks like a typo,record its offset and length.
            if ((result.getSuggestionsInfoAt(i).getSuggestionsAttributes()
                    & SuggestionsInfo.RESULT_ATTR_LOOKS_LIKE_TYPO)
                    == SuggestionsInfo.RESULT_ATTR_LOOKS_LIKE_TYPO) {
                offsets.add(result.getoffsetAt(i));
                lengths.add(result.getLengthAt(i));
            }
        }
    }

    nativeProcessspellCheckResults(mNativeSpellCheckerSessionBridge,convertListToArray(offsets),convertListToArray(lengths));
}

@Override
public SentenceSuggestionsInfo[] onGetSentenceSuggestionsMultiple(TextInfo[] textInfos,int suggestionsLimit) {
    final SentenceSuggestionsInfo[] retval =
            super.onGetSentenceSuggestionsMultiple(textInfos,retval[i]);
        if (tempSsi != null) {
            retval[i] = tempSsi;
        }
    }
    return retval;
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
public static SentenceSuggestionsInfo reconstructSuggestions(
        SentenceTextInfoParams originalTextInfoParams,SuggestionsInfo[] results) {
    if (results == null || results.length == 0) {
        return null;
    }
    if (originalTextInfoParams == null) {
        return null;
    }
    final int originalCookie = originalTextInfoParams.mOriginalTextInfo.getCookie();
    final int originalSequence =
            originalTextInfoParams.mOriginalTextInfo.getSequence();

    final int querySize = originalTextInfoParams.mSize;
    final int[] offsets = new int[querySize];
    final int[] lengths = new int[querySize];
    final SuggestionsInfo[] reconstructedSuggestions = new SuggestionsInfo[querySize];
    for (int i = 0; i < querySize; ++i) {
        final SentenceWordItem item = originalTextInfoParams.mItems.get(i);
        SuggestionsInfo result = null;
        for (int j = 0; j < results.length; ++j) {
            final SuggestionsInfo cur = results[j];
            if (cur != null && cur.getSequence() == item.mTextInfo.getSequence()) {
                result = cur;
                result.setCookieAndSequence(originalCookie,originalSequence);
                break;
            }
        }
        offsets[i] = item.mStart;
        lengths[i] = item.mLength;
        reconstructedSuggestions[i] = result != null ? result : EMPTY_SUGGESTIONS_INFO;
    }
    return new SentenceSuggestionsInfo(reconstructedSuggestions,offsets,lengths);
}

/**
 * Get sentence suggestions for specified texts in an array of TextInfo. This is taken from
 * SpellCheckerService#onGetSentenceSuggestionsMultiple that we can't use because it's
 * using private variables.
 * The default implementation splits the input text to words and returns
 * {@link SentenceSuggestionsInfo} which contains suggestions for each word.
 * This function will run on the incoming IPC thread.
 * So,this is not called on the main thread,* but will be called in series on another thread.
 * @param textInfos an array of the text Metadata
 * @param suggestionsLimit the maximum number of suggestions to be returned
 * @return an array of {@link SentenceSuggestionsInfo} returned by
 * {@link android.service.textservice.SpellCheckerService.Session#onGetSuggestions(TextInfo,int)}
 */
private SentenceSuggestionsInfo[] splitAndSuggest(TextInfo[] textInfos,int suggestionsLimit) {
    if (textInfos == null || textInfos.length == 0) {
        return SentenceLevelAdapter.getEmptySentenceSuggestionsInfo();
    }
    SentenceLevelAdapter sentenceLevelAdapter;
    synchronized(this) {
        sentenceLevelAdapter = mSentenceLevelAdapter;
        if (sentenceLevelAdapter == null) {
            final String localeStr = getLocale();
            if (!TextUtils.isEmpty(localeStr)) {
                sentenceLevelAdapter = new SentenceLevelAdapter(mResources,new Locale(localeStr));
                mSentenceLevelAdapter = sentenceLevelAdapter;
            }
        }
    }
    if (sentenceLevelAdapter == null) {
        return SentenceLevelAdapter.getEmptySentenceSuggestionsInfo();
    }
    final int infosSize = textInfos.length;
    final SentenceSuggestionsInfo[] retval = new SentenceSuggestionsInfo[infosSize];
    for (int i = 0; i < infosSize; ++i) {
        final SentenceLevelAdapter.SentenceTextInfoParams textInfoParams =
                sentenceLevelAdapter.getSplitWords(textInfos[i]);
        final ArrayList<SentenceLevelAdapter.SentenceWordItem> mItems =
                textInfoParams.mItems;
        final int itemsSize = mItems.size();
        final TextInfo[] splitTextInfos = new TextInfo[itemsSize];
        for (int j = 0; j < itemsSize; ++j) {
            splitTextInfos[j] = mItems.get(j).mTextInfo;
        }
        retval[i] = SentenceLevelAdapter.reconstructSuggestions(
                textInfoParams,onGetSuggestionsMultiple(
                        splitTextInfos,suggestionsLimit,true));
    }
    return retval;
}

/**
 * Checks for typos and sends results back to native through a JNI call.
 * @param results Results returned by the Android spellchecker.
 */
@Override
public void onGetSentenceSuggestions(SentenceSuggestionsInfo[] results) {
    mStopMs = SystemClock.elapsedRealtime();

    if (mNativeSpellCheckerSessionBridge == 0) {
        return;
    }

    ArrayList<Integer> offsets = new ArrayList<Integer>();
    ArrayList<Integer> lengths = new ArrayList<Integer>();

    for (SentenceSuggestionsInfo result : results) {
        if (result == null) {
            // In some cases null can be returned by the selected spellchecking service,// see crbug.com/651458. In this case skip to next result to avoid a
            // NullPointerException later on.
            continue;
        }
        for (int i = 0; i < result.getSuggestionsCount(); i++) {
            // If a word looks like a typo,record its offset and length.
            if ((result.getSuggestionsInfoAt(i).getSuggestionsAttributes()
                    & SuggestionsInfo.RESULT_ATTR_LOOKS_LIKE_TYPO)
                    == SuggestionsInfo.RESULT_ATTR_LOOKS_LIKE_TYPO) {
                offsets.add(result.getoffsetAt(i));
                lengths.add(result.getLengthAt(i));
            }
        }
    }
    nativeProcessspellCheckResults(mNativeSpellCheckerSessionBridge,convertListToArray(lengths));

    RecordHistogram.recordTimesHistogram("SpellCheck.Android.Latency",mStopMs - mStartMs,TimeUnit.MILLISECONDS);
}

public static SentenceSuggestionsInfo[] getEmptySentenceSuggestionsInfo() {
    return EmptySentenceSuggestionsInfosInitializationHolder.EMPTY_SENTENCE_SUGGESTIONS_INFOS;
}

@Override
public void onGetSentenceSuggestions(SentenceSuggestionsInfo[] results) {


}

/**
 * Constructs a SpellCheckerSessionBridge object as well as its SpellCheckerSession object.
 * @param nativeSpellCheckerSessionBridge Pointer to the native SpellCheckerSessionBridge.
 */
private SpellCheckerSessionBridge(long nativeSpellCheckerSessionBridge) {
    mNativeSpellCheckerSessionBridge = nativeSpellCheckerSessionBridge;

    Context context = ApplicationStatus.getApplicationContext();
    final TextServicesManager textServicesManager =
            (TextServicesManager) context.getSystemService(
                    Context.TEXT_SERVICES_MANAGER_SERVICE);

    // This combination of parameters will cause the spellchecker to be based off of
    // the language specified at "Settings > Language & input > Spell checker > Language".
    // If that setting is set to "Use system language" and the system language is not on the
    // list of supported spellcheck languages,this call will return null.  This call will also
    // return null if the user has turned spellchecking off at "Settings > Language & input >
    // Spell checker".
    mSpellCheckerSession = textServicesManager.newSpellCheckerSession(null,null,this,true);
}

/**
 * Constructs a SpellCheckerSessionBridge object as well as its SpellCheckerSession object.
 * @param nativeSpellCheckerSessionBridge Pointer to the native SpellCheckerSessionBridge.
 */
private SpellCheckerSessionBridge(long nativeSpellCheckerSessionBridge) {
    mNativeSpellCheckerSessionBridge = nativeSpellCheckerSessionBridge;

    Context context = ContextUtils.getApplicationContext();
    final TextServicesManager textServicesManager =
            (TextServicesManager) context.getSystemService(
                    Context.TEXT_SERVICES_MANAGER_SERVICE);

    // This combination of parameters will cause the spellchecker to be based off of
    // the language specified at "Settings > Language & input > Spell checker > Language".
    // If that setting is set to "Use system language" and the system language is not on the
    // list of supported spellcheck languages,true);
}

/**
 * Main initialization of the input method component. Be sure to call
 * to super class.
 */

@Override public void onCreate() {
    super.onCreate();
    mInputMethodManager = (InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
    mWordSeparators = getResources().getString(R.string.word_separators);
    final TextServicesManager tsm = (TextServicesManager) getSystemService(
            Context.TEXT_SERVICES_MANAGER_SERVICE);
    mScs = tsm.newSpellCheckerSession(null,true);
}

@Override
public void onResume() {
    super.onResume();
    final TextServicesManager tsm = (TextServicesManager) getSystemService(
            Context.TEXT_SERVICES_MANAGER_SERVICE);
    mScs = tsm.newSpellCheckerSession(null,true);

    if (mScs != null) {
        // Instantiate TextInfo for each query
        // TextInfo can be passed a sequence number and a cookie number to identify the result
        if (isSentenceSpellCheckSupported()) {
            // Note that getSentenceSuggestions works on JB or later.
            Log.d(TAG,"Sentence spellchecking supported.");
            mScs.getSentenceSuggestions(new TextInfo[] {new TextInfo("tgisis")},3);
            mScs.getSentenceSuggestions(new TextInfo[] {new TextInfo(
                    "I wold like to here form you")},3);
            mScs.getSentenceSuggestions(new TextInfo[] {new TextInfo("hell othere")},3);
        } else {
            // Note that getSuggestions() is a deprecated API.
            // It is recommended for an application running on Jelly Bean or later
            // to call getSentenceSuggestions() only.
            mScs.getSuggestions(new TextInfo("tgis"),3);
            mScs.getSuggestions(new TextInfo("hllo"),3);
            mScs.getSuggestions(new TextInfo("helloworld"),3);
        }
    } else {
        Log.e(TAG,"Couldn't obtain the spell checker service.");
    }
}

private void updateTextServicesLocaleLocked() {
    final TextServicesManager textServicesManager = (TextServicesManager)
            mContext.getSystemService(Context.TEXT_SERVICES_MANAGER_SERVICE);
    final SpellCheckerSubtype subtype = textServicesManager.getCurrentSpellCheckerSubtype(true);
    final Locale locale;
    if (subtype != null) {
        locale = SpellCheckerSubtype.constructLocaleFromString(subtype.getLocale());
    } else {
        locale = null;
    }
    mCurrentSpellCheckerLocaleCache = locale;
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.spellchecker);
    check = (Button) findViewById(R.id.checkerbuttoncheck);
    checktext = (EditText) findViewById(R.id.checkeredittext);
    suggestBox = (TextView) findViewById(R.id.checkersuggestview);
    rightBox = (TextView) findViewById(R.id.righttext);
    preferences = this.getSharedPreferences("team7663.project.camword",Context.MODE_PRIVATE);
    preferences.edit().putBoolean("team7663.project.camword.OCR.mainoff",true).apply();
    checktext.setText(preferences.getString("team7663.project.camword.OCR.savespell",""));
    TextServicesManager tsm = (TextServicesManager) getSystemService(Context.TEXT_SERVICES_MANAGER_SERVICE);
    scs = tsm.newSpellCheckerSession(null,SpellChecker.this,true);
    MainActivity.spell.setBackgroundResource(R.drawable.spell);
    check.setonClickListener(new View.OnClickListener() {


        @SuppressWarnings("deprecation")
        @Override
        public void onClick(View v){
            value = checktext.getText().toString();
            rightBox.setText("");
            if(value.isEmpty()==false)
            {
            scs.getSuggestions(new TextInfo(value),5);
            }
            }
    });
   }

/**
 * 返回 {@link TextServicesManager}
 */
public static TextServicesManager getTextServicesManager()
{
    return (TextServicesManager) get(TEXT_SERVICES_MANAGER_SERVICE);
}

@TargetApi(14)
public static TextServicesManager getTextServicesManager() {
    return (TextServicesManager) getSystemService(Context.TEXT_SERVICES_MANAGER_SERVICE);
}

public static TextServicesManager textServices(Context context) {
    return (TextServicesManager) context.getSystemService(TEXT_SERVICES_MANAGER_SERVICE);
}

public static TextServicesManager textServicesManager() {
    return (TextServicesManager) get(Context.TEXT_SERVICES_MANAGER_SERVICE);
}

/**
 * Obtain a {@link TextServicesManager} instance associated with specified {@link Context}
 *
 * @param context Context
 * @return {@link TextServicesManager} associated with specified {@link Context}
 * @throws InvalidContextException if {@link TextServicesManager} can't be obtained
 *                                 from specified {@link Context}
 */
@NonNull
public static TextServicesManager getTextServicesManager(@NonNull Context context) {
    return validate(context.getSystemService(Context.TEXT_SERVICES_MANAGER_SERVICE));
}

@Override
public void onCreateContextMenu(ContextMenu menu,View view,ContextMenuInfo menuInfo) {
    final android.view.ContextMenu nativeMenu;
    if (menu instanceof ContextMenuWrapper) {
        nativeMenu = ((ContextMenuWrapper) menu).unwrap();
        super.onCreateContextMenu(nativeMenu,view,menuInfo);
        if (view instanceof ContextMenuCallbackGetter) {
            final OnCreateContextMenuListener l = ((ContextMenuCallbackGetter) view)
                    .getonCreateContextMenuListener();
            if (l != null) {
                l.onCreateContextMenu(nativeMenu,menuInfo);
            }
        }
    }
}

private void initListView() {
    listView.setonCreateContextMenuListener(new OnCreateContextMenuListener() {

        @Override
        public void onCreateContextMenu(ContextMenu menu,View v,ContextMenuInfo menuInfo) {
            menu.setHeaderTitle("选择操作");
            menu.add(0,"修改");
            menu.add(0,1,"删除");
        }
    });

    listView.setonItemClickListener(new OnItemClickListener() {

        @Override
        public void onItemClick(AdapterView<?> arg0,View arg1,int index,long itemId) {
        }
    });
}

@Override
public void onCreateContextMenu(ContextMenu menu,menuInfo);
            }
        }
    }
}

private void setListViewContextMenuWithDel() {
    lvMang.setonCreateContextMenuListener(new OnCreateContextMenuListener() {

        @Override
        public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo) {
            intCurrDataPos = ((AdapterContextMenuInfo) menuInfo).position;
            menu.add(0,"删除");
        }
    });
}

private void setListViewContextMenuWithDel_Resume() {
    lvMang.setonCreateContextMenuListener(new OnCreateContextMenuListener() {

        @Override
        public void onCreateContextMenu(ContextMenu menu,"删除");
            menu.add(0,"恢复所有已暂停车次");
        }
    });
}

@Override
public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo) {
    super.onCreateContextMenu(menu,menuInfo);
    if (view instanceof ContextMenuCallbackGetter) {
        final OnCreateContextMenuListener l = ((ContextMenuCallbackGetter) view)
                .getonCreateContextMenuListener();
        if (l != null) {
            l.onCreateContextMenu(menu,menuInfo);
        }
    }
}

public void init()   
{
    resolver = getContentResolver();
    bookList = DbDataOperation.getBookInfo(resolver);

    lvBookshelf = (ListView)findViewById(R.id.lvBookshelf);
    filebrowser = (Filebrowser)findViewById(R.id.filebrowser);
    filebrowser.setonFilebrowserListener(this);
    lvBookshelf.setonItemClickListener(this);
    ll=(RelativeLayout)findViewById(R.id.content);

    adapter = new CustomAdapter();
    lvBookshelf.setAdapter(adapter);
    lvBookshelf.setonCreateContextMenuListener(new OnCreateContextMenuListener()
    {
        public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo)
        {
            AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
            bookPosition = info.position;
            menu.add(Menu.NONE,R.id.menu_open,"打开");
            menu.add(Menu.NONE,R.id.menu_del,"删除 " ); 
            menu.add(Menu.NONE,R.id.menu_des,"详细 " ); 
        }
    });
       titleTextV=(TextView)findViewById(R.id.profile_header_title);
       titleTextV.setText("本地文件");
       backImageV=(ImageView)findViewById(R.id.profile_header_back);
       backImageV.setonClickListener(new OnClickListener(){

               public void onClick(View arg0) {
                   // Todo Auto-generated method stub
                   ll.setVisibility(View.INVISIBLE);
               }

           });
}

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    lvBookMark = getListView();
    resolver = getContentResolver();
    bookMarks = DbDataOperation.getBookMark(resolver);
    lvBookMark.setBackgroundResource(R.drawable.bg_listview);
    lvBookMark.setAdapter(adapter);
    lvBookMark.setDivider(null);
    lvBookMark.setCacheColorHint(000000);
    lvBookMark.setonItemClickListener(new OnItemClickListener()
    {
        public void onItemClick(AdapterView<?> parent,int position,long id)
        {
            currentPosition = position;
            intentToRead();
        }
    });
    lvBookMark.setonCreateContextMenuListener(new OnCreateContextMenuListener()
    {
        public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo)
        {
            AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
            currentPosition = info.position;
            menu.add(Menu.NONE,"详细 " ); 

        }
    });
}

private void addImage(String uri,boolean temporary,String rating) {
        if (attachments.size() >= 5)
            return;
        AsyncImageView image = new AsyncImageView(this);
        image.setScaleType(ScaleType.CENTER_INSIDE);
        Bitmap b = loadBitmap(uri);
        if(b == null)
            return;
        image.setimageBitmap(b);
        image.setTag(attachments.size());
        image.setAdjustViewBounds(true);
        image.setPadding(4,2,4,2);
        registerForContextMenu(image);
        image.setonCreateContextMenuListener(new OnCreateContextMenuListener() {
            @Override
            public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo) {
//              menu.setHeaderTitle("Select rating");
                int i;
                for (i = 0; i < ratings.length; i++) {
                    menu.add(Menu.NONE,(Integer) v.getTag(),i,ratings[i]);
                }
                menu.add(Menu.NONE,i++,R.string.crop);
                menu.add(Menu.NONE,R.string.resize);
                menu.add(Menu.NONE,R.string.delete);
            }
        });
        LinearLayout scroll = (LinearLayout) findViewById(R.id.picsScroll);
        scroll.addView(image);
        NewPostAttachment at = new NewPostAttachment(uri,rating);
        at.setimageView(image);
        if (temporary)
            at.delete_after = true;
        attachments.add(at);
    }

/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.hc);
    StatusBarUtil.setColor(this,getResources().getColor(R.color.colorPrimary));
    toolbar = (android.support.v7.widget.Toolbar)
        findViewById(R.id.toolbar);
//      初始化Toolbar控件
    setSupportActionBar(toolbar);
//      用Toolbar取代ActionBar
    //toolbar.setTitleTextColor(getResources().getColor(R.color.text_font_white));//标题颜色
    //  toolbar.setSubtitleTextColor(getResources().getColor(R.color.text_font_white));//副标题颜色


//      设置导航按钮监听
    //overridePendingTransition(R.anim.out_to_right,R.anim.in_from_left);
    bn_add = (Button)findViewById(R.id.bn_add);
    bn_clear = (Button)findViewById(R.id.bn_clear);
    bn_hc = (Button)findViewById(R.id.bn_hc);
    list = (GridView)findViewById(R.id.list);

    bn_add.setonClickListener(this);
    bn_clear.setonClickListener(this);
    bn_hc.setonClickListener(this);
    IntentFilter intentFilter=new IntentFilter();
    intentFilter.addAction(THIS_ACTION);
    registerReceiver(br,intentFilter);
    //FileList.curpath = "/mnt/sdcard";
    FileList.curpath = Environment.getExternalStorageDirectory().getAbsolutePath();
    FileList.broadcastAction = THIS_ACTION;
    initAdapter();
    formatter = new SimpleDateFormat("yyyy-MM-dd HH_mm_ss"); 
    //广告初始化

    sp = PreferenceManager.getDefaultSharedPreferences(this);
    list.setonCreateContextMenuListener(new OnCreateContextMenuListener(){
        @Override
        public void onCreateContextMenu(ContextMenu p1,View p2,ContextMenu.ContextMenuInfo p3)
        {
            // Todo: Implement this method
            //p1.setHeaderTitle("选项");
            //第二个参数是id
            p1.add(0,"设置持续时间");
            p1.add(0,"移除该图片");

        }
        });
    }

/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
    setContentView(R.layout.fj);
    StatusBarUtil.setColor(this,getResources().getColor(R.color.colorPrimary));
    toolbar = (android.support.v7.widget.Toolbar)
        findViewById(R.id.toolbar);
//      初始化Toolbar控件
    setSupportActionBar(toolbar);
//      用Toolbar取代ActionBar
    //toolbar.setTitleTextColor(getResources().getColor(R.color.text_font_white));//标题颜色
    //toolbar.setSubtitleTextColor(getResources().getColor(R.color.text_font_white));//副标题颜色



//      设置导航按钮监听
    //overridePendingTransition(R.anim.out_to_right,R.anim.in_from_left);
    bn_add = (Button)findViewById(R.id.bn_add2);
    bn_clear = (Button)findViewById(R.id.bn_clear2);
    bn_hc = (Button)findViewById(R.id.bn_fj);
    list = (ListView)findViewById(R.id.list2);

    bn_add.setonClickListener(this);
    bn_clear.setonClickListener(this);
    bn_hc.setonClickListener(this);
    IntentFilter intentFilter=new IntentFilter();
    intentFilter.addAction(THIS_ACTION);
    registerReceiver(br,intentFilter);
    FileList.curpath = Environment.getExternalStorageDirectory().getAbsolutePath();
    //FileList.filter = ".*.gif$";
    FileList.broadcastAction = THIS_ACTION;
    initAdapter();
    sp = PreferenceManager.getDefaultSharedPreferences(this);

    list.setonCreateContextMenuListener(new OnCreateContextMenuListener(){
        @Override
        public void onCreateContextMenu(ContextMenu p1,ContextMenu.ContextMenuInfo p3)
        {
            // Todo: Implement this method
            p1.add(0,"移除该图片");
        }
        });
    }

@Override
    public View getChildView(int groupPosition,int childPosition,boolean isLastChild,View convertView,ViewGroup parent) {
        if (mLstDatas == null || mLstDatas.size() == 0){
            return null;
        }
        final int groupPos = groupPosition;
        ChildViewHolder holder;
        if (convertView != null){
            holder = (ChildViewHolder) convertView.getTag();
        }else{
            convertView = mInflater.inflate(R.layout.item_a6_order,null);
            holder = new ChildViewHolder();
            holder.slv1 = (SubListView)convertView.findViewById(R.id.item_a6_order_slv1);
            convertView.setTag(holder);
        }
        holder.slv1.setonCreateContextMenuListener(new OnCreateContextMenuListener() {

            @Override
            public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo) {
                mCurrGroupPos = groupPos;
                mCurrChildItemPos = ((AdapterContextMenuInfo) menuInfo).position;
                menu.clear();
                menu.add(A6OrderAty.CONTEXT_GROUP_0,A6OrderAty.CONTEXT_ITEM_ADD_TRAIN_INFO,"添加车次");
                TicketInfo tInfo = mLstDatas.get(groupPos).getTickets().get(mCurrChildItemPos);
                try {
                    Date trainDate = TimeUtil.getDTFormat().parse(tInfo.getStart_train_date_page());
                    if (trainDate.getTime() >= (new Date()).getTime()){
                        if (tInfo.getReturn_flag().equals("Y")){
                            //退票
                            menu.add(A6OrderAty.CONTEXT_GROUP_0,A6OrderAty.CONTEXT_ITEM_refund_TICKET,"退票");
                        }
//                      if (tInfo.getResign_flag().equals("Y")){
//                          //改签
//                          menu.add(A6OrderAty.CONTEXT_GROUP_0,A6OrderAty.CONTEXT_ITEM_RESIGN,"改签");
//                      }
                    }
                } catch (ParseException e) {
                    e.printstacktrace();
                }
            }
        });
        A6OrderItemAdapter adapter = new A6OrderItemAdapter(mContext,mLstDatas.get(groupPosition).getTickets());
        holder.slv1.setAdapter(adapter);
        return convertView;
    }

/**
* @see View#setonCreateContextMenuListener(OnCreateContextMenuListener)
*/
 public W setonCreateContextMenuListener(OnCreateContextMenuListener l) {
     mView.setonCreateContextMenuListener(l);
     return (W)this;
 }

@Override
protected void onCreate(Bundle savedInstanceState) {
    if (Maintabactivity.isLightTheme(this)) {
        setTheme(R.style.Theme_Light);
    }

    super.onCreate(savedInstanceState);

    FeedName = null;

    iconBytes = null;

    Intent intent = getIntent();

    FeedId = intent.getLongExtra(FeedData.FeedColumns._ID,0);
    uri = intent.getData();

    if (FeedId > 0) {
        Cursor cursor = getContentResolver().query(FeedData.FeedColumns.CONTENT_URI(FeedId),Feed_PROJECTION,null,null);

        if (cursor.movetoFirst()) {
            FeedName = cursor.isNull(0) ? cursor.getString(1) : cursor.getString(0);
            iconBytes = cursor.getBlob(2);
            hideRead = cursor.getInt(3) == 1;
        }
        cursor.close();
    } else {
        hideRead = PreferenceManager.getDefaultSharedPreferences(this).getBoolean(new StringBuilder(uri.equals(FeedData.EntryColumns.FAVORITES_CONTENT_URI) ? FAVORITES : ALLENTRIES).append('.').append(FeedData.FeedColumns.HIDE_READ).toString(),false);
    }

    if (!Maintabactivity.POSTGINGERBREAD && iconBytes != null && iconBytes.length > 0) { // we cannot insert the icon here because it would be overwritten,but we have to reserve the icon here
        if (!requestwindowFeature(Window.FEATURE_LEFT_ICON)) {
            iconBytes = null;
        }
    }

    setContentView(R.layout.entries);

    entrieslistadapter = new Entrieslistadapter(this,uri,intent.getBooleanExtra(EXTRA_SHOWFeedINFO,false),intent.getBooleanExtra(EXTRA_AUTORELOAD,hideRead);
    setlistadapter(entrieslistadapter);

    if (FeedName != null) {
        setTitle(FeedName);
    }
    if (iconBytes != null && iconBytes.length > 0) {
        int bitmapSizeInDip = (int)TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,24f,getResources().getdisplayMetrics());
        Bitmap bitmap = BitmapFactory.decodeByteArray(iconBytes,iconBytes.length);
        if (bitmap != null) {
            if (bitmap.getHeight() != bitmapSizeInDip) {
                bitmap = Bitmap.createScaledBitmap(bitmap,bitmapSizeInDip,false);
            }

            if (Maintabactivity.POSTGINGERBREAD) {
                CompatibilityHelper.setActionBarDrawable(this,new BitmapDrawable(bitmap));
            } else {
                setFeatureDrawable(Window.FEATURE_LEFT_ICON,new BitmapDrawable(bitmap));
            }
        }
    }
    if (RSSOverview.notificationmanager != null) {
        RSSOverview.notificationmanager.cancel(0);
    }

    getListView().setonCreateContextMenuListener(new OnCreateContextMenuListener() {
        public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo) {
            menu.setHeaderTitle(((TextView) ((AdapterView.AdapterContextMenuInfo) menuInfo).targetView.findViewById(android.R.id.text1)).getText());
            menu.add(0,CONTEXTMENU_MARKASREAD_ID,Menu.NONE,R.string.contextmenu_markasread).setIcon(android.R.drawable.ic_menu_manage);
            menu.add(0,CONTEXTMENU_MARKASUNREAD_ID,R.string.contextmenu_markasunread).setIcon(android.R.drawable.ic_menu_manage);
            //menu.add(0,CONTEXTMENU_DELETE_ID,R.string.contextmenu_delete).setIcon(android.R.drawable.ic_menu_delete);
            menu.add(0,CONTEXTMENU_copYURL,R.string.contextmenu_copyurl).setIcon(android.R.drawable.ic_menu_share);
        }
    });
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.archives_display);

    // ��Layout�����ListView
    list = (ListView) findViewById(R.id.archives_display_ListView);

    // ���ɶ�̬���飬��������
    listItem = new ArrayList<HashMap<String,Object>>();

    //��ȡ��Ϸ�浵
    String[] fileNames = archiveContorller.getArchiveDir();
    for(int i = 0; i<fileNames.length;i++){
        HashMap<String,Object> map = new HashMap<String,Object>();
        map.put("archives_display_ItemImage",R.drawable.icon);// ͼ����Դ��ID
        //map.put("archives_display_ItemText01","�浵 " + (i+1));
        map.put("archives_display_ItemText01","��Ϸ�浵 ");
        map.put("archives_display_ItemText02",fileNames[i].subSequence(0,fileNames[i].length()-4));
        listItem.add(map);
    }

    // ������������Item�Ͷ�̬�����Ӧ��Ԫ��
    listItemAdapter = new SimpleAdapter(this,listItem,// ����Դ
            R.layout.archives_display_item,// ListItem��XMLʵ��
            // ��̬������ImageItem��Ӧ������
            new String[] { "archives_display_ItemImage","archives_display_ItemText01","archives_display_ItemText02" },// ImageItem��XML�ļ������һ��ImageView,����TextView ID
            new int[] { R.id.archives_display_ItemImage,R.id.archives_display_ItemText01,R.id.archives_display_ItemText02 });

    // ��Ӳ�����ʾ
    list.setAdapter(listItemAdapter);


    // ��ӵ��
    list.setonItemClickListener(new OnItemClickListener() {

        @Override
        public void onItemClick(AdapterView<?> arg0,int arg2,long arg3) {
            //��ô浵����
            String fileName = (String)listItem.get(arg2).get("archives_display_ItemText02");
            fileName +=".txt";

            //������Ϸ������Ϣ
            boolean flag = archiveContorller.readArchiveFile(fileName);

            //����������Ϣ
            ChineseChess.resetChessmanPosition();

            //��ת����Ϸ����
            Intent intent = new Intent();
            intent.setClass(ArchiveManagerActivity.this,GameViewActivity.class);
            ArchiveManagerActivity.this.startActivity(intent);

            //setTitle("�����" + arg2 + "����Ŀ");
        }
    });

    // ��ӳ������
    list.setonCreateContextMenuListener(new OnCreateContextMenuListener() {

        @Override
        public void onCreateContextMenu(ContextMenu menu,ContextMenuInfo menuInfo) {
            menu.setHeaderTitle("�浵ѡ��");
            menu.add(0,"ɾ��");
            menu.add(0,"ȡ��");
        }
    });
}

public OnCreateContextMenuListener getonCreateContextMenuListener();

public OnCreateContextMenuListener getonCreateContextMenuListener();

public OnCreateContextMenuListener getonCreateContextMenuListener();