MyApplication

package com.companyName.dvbott;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Application;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageInfo;
import android.net.NetworkInfo;
import android.net.NetworkInfo.DetailedState;
import android.os.AsyncTask;
import android.util.Log;
import android.view.WindowManager;

import com.companyName.base.ActivityManager;
import com.companyName.dvbott.IDFManager.IDFManager;
import com.companyName.dvbott.service.ReminderService;
import com.companyName.dvbott.usercenter.util.MySharePerfance;
import com.companyName.dvbott.util.EventAction;
import com.companyName.dvbott.util.PreferencesHelper;
import com.companyName.dvbott.util.Session;
import com.companyName.enums.PackageType;
import com.companyName.enums.PlayType;
import com.companyName.enums.VideoType;
import com.companyName.multiscreen.flysee.util.FlyConstant;
import com.companyName.ott.phone.R;
import com.companyName.protocol.core.Client;
import com.companyName.protocol.core.IDFDevice;
import com.companyName.protocol.core.OnDeviceChangedListener;
import com.companyName.protocol.core.OnDeviceSearchListener;
import com.companyName.protocol.enums.ConnectionStatus;
import com.companyName.protocol.util.IDFConfig;
import com.companyName.transport.IDFMsisAgent;
import com.companyName.transport.InterfaceUrls;
import com.companyName.transport.dto.BaseJsonBean;
import com.companyName.transport.dto.live.ChannelInfo;
import com.companyName.transport.dto.system.BitRate;
import com.companyName.transport.dto.system.BitRatesJson;
import com.companyName.transport.dto.vod.AssetListInfo;
import com.companyName.transport.dto.vod.Catalog;
import com.companyName.transport.dto.vod.CatalogJson;
import com.companyName.transport.enums.TerminalType;
import com.companyName.transport.framework.IDFServiceAgentConfig;
import com.companyName.transport.framework.RequestListener;
import com.companyName.transport.requestparameters.GetBitRateParameters;
import com.companyName.transport.requestparameters.GetCatalogParameters;
import com.companyName.transport.requestparameters.GetRecommendResourceParameters;
import com.companyName.transport.util.IDFError;
import com.companyName.transport.util.IDFToast;
import com.companyName.util.IDFPersistentMap;
import com.companyName.util.IDFTextUtil;
import com.companyName.util.ILog;
import com.companyName.util.db.DatabaseManager;
import com.companyName.util.db.DownloadHelper;
import com.companyName.util.log.IDFLog;
import com.nostra13.universalimageloader.cache.disc.impl.UnlimitedDiscCache;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.nostra13.universalimageloader.utils.StorageUtils;

import de.greenrobot.event.EventBus;

public class MyApplication extends Application implements OnDeviceChangedListener,
        OnDeviceSearchListener {
    // 消息总线
    public static EventBus eventBus = new EventBus();
    private static MyApplication instance;
    public static PackageType packageType = PackageType.BASE;
    public static DatabaseManager mdba = null;
    public static boolean isAddFavourited = false;
    /** 下载工具类 */
    public static DownloadHelper downloadHelper;

    private Map<String, AssetListInfo> userFavourite = null;

    private TreeMap<String, ChannelInfo> myFavouriteChannels = null; // 我喜爱的频道

//    public static String myFavouriteChannelFileName = "/myFavouriteChannel.data";

    /** 服务器时间与本地时间偏移量单位（S）deltatime = 服务器时间 - 当前时间 */
    public static long deltatime = 0;
    /** 影视 (2级)栏目点击catalogID */
    public static String secondCatalogIdSelected = "";
    // subId
    public static int subId;
    // 码率全部信息
    public static List<BitRate> BitStates;
    // 400,800,1200,1600中间用逗号区分/// getPlayUrl bitRate = 400K
    // 返回一个：标清
    // 返回二个：标清、高清
    // 返回三个：流畅、标清、高清
    // 返回四个：流畅、标清、高清、超清
    public static String videoBitrates;
    /**
     * 暂时没有测试用的天威智能卡号密码，设置一个debug模式。不去验证接口，只处理ui逻辑
     */
    public static final boolean DEBUG = true;

    // -------------------- miracast begin --------------------
    /** 投投看连接成功全局变量 0：MIRCASTSTATE_DIS 断开 */
    public static final int MIRCASTSTATE_DIS = 0;

    /** 投投看连接成功全局变量 1: MIRCASTSTATE_CON 成功 */
    public static final int MIRCASTSTATE_CON = 1;

    /** 投投看连接中全局变量 2： MIRCASTSTATE_CONNECTING */
    public static final int MIRCASTSTATE_CONNECTING = 2;

    /** 投投看断开连接中全局变量 3： MIRCASTSTATE_DISCONNECTING */
    public static final int MIRCASTSTATE_DISCONNECTING = 3;

    /** 投投看初始状态全局变量 4： MIRCASTSTATE_INIT */
    public static final int MIRCASTSTATE_INIT = 4;

    public static final boolean feifeikanMode = true;
    /**
     * 投投看连接状态全局变量<br>
     * 0: MIRCASTSTATE_DIS 断开<br>
     * 1: MIRCASTSTATE_CON 成功<br>
     * 2: MIRCASTSTATE_CONNECTING
     */
    public static int wfdApState = MIRCASTSTATE_DIS;

    public static final int RSTP_PORT_TD = 6512;

    public static final int RSTP_PORT_F1 = 8554;

    /** 基于marvell芯片的Miracast AP模式 */
    public static final String MIRACAST_AP_MARVELL = "marvell";

    /** 基于broadcom芯片的Miracast AP模式 */
    public static final String MIRACAST_AP_BROADCOM = "broadcom";

    private ConnectionStatus mConnectionStatus = ConnectionStatus.DISCONNECTED;

    public static int ILOGLEVEL = Log.ERROR;

    public static int IDFLOGLEVEL = Log.ERROR;

    public static boolean hasBind = false;

    private AlertDialog aDialog;

    public static long loginDialogDismissTime;

    // -------------------- miracast end --------------------

    public static MyApplication getInstance() {
        return instance;
    }

    public void onCreate() {
        super.onCreate();
        mContext = getApplicationContext();
        instance = this;
        WindowManager wm = (WindowManager) this.getBaseContext().getSystemService(
                Context.WINDOW_SERVICE);
        width = wm.getDefaultDisplay().getWidth();
        height = wm.getDefaultDisplay().getHeight();

        PackageInfo info;
        try {
            info = getPackageManager().getPackageInfo(getPackageName(), 0);
            packageType = PackageType.getEnum(info.packageName);
        } catch (Exception e) {
        }
        mdba = new DatabaseManager(getApplicationContext());
        mdba.open();
        downloadHelper = new DownloadHelper(mdba.mSQLiteDatabase);
        this.startService(mContext);

        configure();

        // 首页推荐预加载
        GetRecommendResourceParameters parameters = new GetRecommendResourceParameters();
        IDFMsisAgent.getInstance().getRecommendResource(parameters, null);
        getCatalog(1, 0);
    }

    /**
     * 启动服务
     *
     * @param context
     */
    private void startService(final Context context) {
        Intent intent = new Intent(mContext, ReminderService.class);
        context.startService(intent);
    }

    // MDNS列表

    // 当前选中DLNA 设备
    public static org.cybergarage.upnp.Device default_dev = null;

    // 个人中心设备操作类型

    // 设备列表
    // public static ArrayList<MdnsDevice> mdnsDeviceList = new
    // ArrayList<MdnsDevice>();

    // public static MdnsDevice choiceDeviced;

    public static DetailedState wifiState;
    public static String curConnectWifiSSID;
    public static String curConnectWifiBSSID;

    public static boolean passwordError = false;

    public static String connectingSSID = null;

    public static boolean isWifiPwdError = false;

    public static NetworkInfo.DetailedState status = DetailedState.SCANNING;

    // public static String tempRoute = null;
    /**
     * 临时创建的device对象
     */
    public static String hasDeviceWifi = null;
    public static String deviceIP = null;
    public static String deviceSSID = null;
    public static String deviceWifiPwd = null;

    public static String accountId = null;
    public static String accountPwd = null;
    public static String routePwd = null;
    public static String routeSSID = null;
    public static Context mContext;

    public static int width = 0;
    public static int height = 0;

    /**
     * 初始化图片加载器
     */
    private void initImageLoader(Context context) {
        File cacheDir = StorageUtils.getOwnCacheDirectory(getApplicationContext(), getPackageName()
                + "/imageloader/Cache");
        DisplayImageOptions options = new DisplayImageOptions.Builder()
                .showImageOnFail(R.drawable.default_poster)
                .showImageForEmptyUri(R.drawable.default_poster)
                .showStubImage(R.drawable.default_poster).cacheInMemory(true).cacheOnDisc(true)
                // .displayer(new FadeInBitmapDisplayer(100))//是否图片加载好后渐入的动画时间
                .build();
        ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)
                .discCache(new UnlimitedDiscCache(cacheDir)).defaultDisplayImageOptions(options)
                // 自定义缓存路径
                .discCacheSize(100 * 1024 * 1024).threadPriority(Thread.MIN_PRIORITY)
                .threadPoolSize(4).tasksProcessingOrder(QueueProcessingType.FIFO).build();
        ImageLoader.getInstance().init(config);
    }

    /**
     * 获取全部码率值
     */
    public static void initBitStates() {
        if (packageType == PackageType.TOPWAY || packageType == PackageType.TOPWAY_PAD) {
            return;
        }
        GetBitRateParameters parameters = new GetBitRateParameters();
        // parameters.setBitRateType("1|2|3|4");// 获取全部码率列表
        IDFMsisAgent.getInstance().getBitRates(parameters, new RequestListener() {
            @Override
            public void onComplete(BaseJsonBean jsonBean) {
                super.onComplete(jsonBean);
                try {
                    if (jsonBean != null) {
                        if (0 == jsonBean.getRet()) {
                            BitRatesJson result = (BitRatesJson) jsonBean;
                            BitStates = result.getBitRates();

                        } else {
                            // IDFToast.makeTextShort(mContext,
                            // jsonBean.getRetInfo());
                            IDFToast.makeTextShort(mContext, jsonBean.getRetInfo());
                            IDFLog.e("TAG", jsonBean.getRetInfo());
                        }
                    } else {
                        IDFLog.e("TAG", "jsonBean==null");
                    }
                } catch (Exception e) {
                    IDFLog.e("TAG", "Exception:" + e.getMessage());
                }
            }

            @Override
            public void onStart() {
                super.onStart();
                IDFLog.d("TAG", "开始获取码率！");
            }

            @Override
            public void onError(IDFError error) {
                super.onError(error);
            }
        });
    }

    /**
     * 获取湖北点播码率
     *
     * @param playType
     * @return
     */
    public static List<BitRate> getHrntBODBitRates() {
        List<BitRate> bitStateData = new ArrayList<BitRate>();
        if(IDFTextUtil.isNull(MyApplication.videoBitrates)) {
            return bitStateData;
        }
        String[] vodBitrates = MyApplication.videoBitrates.split(",");
        if(!IDFTextUtil.isNull(vodBitrates)) {
            int len = vodBitrates.length;
            BitRate bitrate = new BitRate();
            bitrate.setBitRateName("自适应");
            bitrate.setBitRateType(0);
            BitRate bitrate1 = new BitRate();
            BitRate bitrate2 = new BitRate();
            BitRate bitrate3 = new BitRate();
            BitRate bitrate4 = new BitRate();
            // 400,800,1200,1600中间用逗号区分/// getPlayUrl bitRate = 400K
            // 返回一个：标清
            // 返回二个：标清、高清
            // 返回三个：流畅、标清、高清
            // 返回四个：流畅、标清、高清、超清
            if(len == 1) {
                bitrate.setBitRate(vodBitrates[0] + "k");
                bitStateData.add(bitrate);
                bitrate1.setBitRate(vodBitrates[0] + "k");
                bitrate1.setBitRateName("标清");
                bitrate1.setBitRateType(2);
                bitStateData.add(bitrate1);
            } else if(len == 2) {
                bitrate1.setBitRate(vodBitrates[0] + "k");
                bitrate1.setBitRateName("标清");
                bitrate1.setBitRateType(2);
                bitrate2.setBitRate(vodBitrates[1] + "k");
                bitrate2.setBitRateName("高清");
                bitrate2.setBitRateType(3);
                bitrate.setBitRate(vodBitrates[1] + "k");
                bitStateData.add(bitrate);
                bitStateData.add(bitrate1);
                bitStateData.add(bitrate2);
            } else if(len == 3) {
                bitrate1.setBitRate(vodBitrates[0] + "k");
                bitrate1.setBitRateName("流畅");
                bitrate1.setBitRateType(1);
                bitrate2.setBitRate(vodBitrates[1] + "k");
                bitrate2.setBitRateName("标清");
                bitrate2.setBitRateType(2);
                bitrate3.setBitRate(vodBitrates[2] + "k");
                bitrate3.setBitRateName("高清");
                bitrate3.setBitRateType(3);
                bitrate.setBitRate(vodBitrates[2] + "k");
                bitStateData.add(bitrate);
                bitStateData.add(bitrate1);
                bitStateData.add(bitrate2);
                bitStateData.add(bitrate3);
            } else if(len == 4) {
                bitrate1.setBitRate(vodBitrates[0] + "k");
                bitrate1.setBitRateName("流畅");
                bitrate1.setBitRateType(1);
                bitrate2.setBitRate(vodBitrates[1] + "k");
                bitrate2.setBitRateName("标清");
                bitrate2.setBitRateType(2);
                bitrate3.setBitRate(vodBitrates[2] + "k");
                bitrate3.setBitRateName("高清");
                bitrate3.setBitRateType(3);
                bitrate4.setBitRate(vodBitrates[3] + "k");
                bitrate4.setBitRateName("超清");
                bitrate4.setBitRateType(3);
                bitrate.setBitRate(vodBitrates[3] + "k");
                bitStateData.add(bitrate);
                bitStateData.add(bitrate1);
                bitStateData.add(bitrate2);
                bitStateData.add(bitrate3);
                bitStateData.add(bitrate4);
            }
            
        }
        return bitStateData;
    }
    
    /**
     * 获取天威码率
     *
     * @param type
     *            0 标清影片 1高清影片
     * @return
     */
    public static List<BitRate> getTopwayBitRates(VideoType videoType) {
        List<BitRate> bitStateData = new ArrayList<BitRate>();
        BitRate bitrate0 = new BitRate();
        BitRate bitrate1 = new BitRate();
        BitRate bitrate2 = new BitRate();
        BitRate bitrate3 = new BitRate();
        if (videoType == VideoType.SD) {

            bitrate0.setBitRate("400k");
            bitrate0.setBitRateName("流畅");
            bitrate0.setBitRateType(1);
            bitrate1.setBitRate("800k");
            bitrate1.setBitRateName("标清");
            bitrate1.setBitRateType(2);
            bitrate2.setBitRate("1200k");
            bitrate2.setBitRateName("高清");
            bitrate2.setBitRateType(3);
        } else if (videoType == VideoType.HD) {
            bitrate0.setBitRate("800k");
            bitrate0.setBitRateName("标清");
            bitrate0.setBitRateType(2);
            bitrate1.setBitRate("1200k");
            bitrate1.setBitRateName("高清");
            bitrate1.setBitRateType(3);
            bitrate2.setBitRate("2000k");
            bitrate2.setBitRateName("超清");
            bitrate2.setBitRateType(4);
        }

        bitrate3.setBitRate("");
        bitrate3.setBitRateName("自适应");
        bitrate3.setBitRateType(0);
        bitStateData.add(bitrate3);
        bitStateData.add(bitrate0);
        bitStateData.add(bitrate1);
        bitStateData.add(bitrate2);
        return bitStateData;
    }

    /**
     * 获取当前媒资的码率列表
     *
     * @param playType
     * @param videoType
     * @return
     */
    public static List<BitRate> getCurAssetBitState(PlayType playType, VideoType videoType) {
        if (packageType == PackageType.TOPWAY || packageType == PackageType.TOPWAY_PAD) {
            return getTopwayBitRates(videoType);
        }
        
        
        // 获取湖北点播码率
        if(packageType == PackageType.HRTN && playType == PlayType.VOD) {
            return getHrntBODBitRates();
        }
        List<BitRate> bitStateData = new ArrayList<BitRate>();
        if (BitStates != null) {
            int count = BitStates.size();
            if (count > 0) {
                switch (playType) {
                case VOD:
                    if (videoType == VideoType.SD) {// 点播标清
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 3) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    } else if (videoType == VideoType.HD) {
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 4) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    }

                    break;
                case PLAYBACK:// 同点播
                    if (videoType == VideoType.SD) {// 点播标清
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 3) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    } else if (videoType == VideoType.HD) {
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 4) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    }
                    break;
                case DELAY:// //同直播
                    if (videoType == VideoType.SD) {// 点播标清
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 1) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    } else if (videoType == VideoType.HD) {
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 2) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    }
                    break;
                case VOB:

                    if (videoType == VideoType.SD) {// 点播标清
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 1) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    } else if (videoType == VideoType.HD) {
                        for (int i = 0; i < count; i++) {
                            if (BitStates.get(i).getBitRateType() == 2) {
                                bitStateData.add(BitStates.get(i));
                            }
                        }
                    }
                    break;
                default:
                    break;
                }
            }
        }
        return bitStateData;
    }

    /**
     * 初始配置参数 一定要先设置configPath存储路径
     */
    private void configure() {

        String pkName = this.getPackageName();
        ILog.configure(true, ILOGLEVEL, "/mnt/sdcard/" + pkName + "/Log/cbb/", 30);
        IDFLog.configure(true, IDFLOGLEVEL, "/mnt/sdcard/" + pkName + "/Log/", 30);
        // 注册捕获未知异常监听，并记录日志
        IDFLog.processGlobalException(this);

        idfConfig();

        // 这个存储路径需要应用层自己保存，并在这里使用。此测试Demo在Setting中保存的
        SharedPreferences settings = mContext.getSharedPreferences("device_config", 0);
        String configPath = settings.getString("configPath", null);

        if (configPath != null) {
            IDFConfig.configPath = configPath + "/config.data";
            // 设置IDFPersistentMap的保存路径
            IDFPersistentMap.savePath = configPath + "/int.data";
        } else {
            IDFConfig.configPath = "/mnt/sdcard/" + pkName + "/config.data";
        }

        IDFConfig config = Client.getConfig();
        config.setUdpEnabled(true);
        config.setMesEnabled(false);
        //config.setXmppEnabled(false);// 关闭协议
        // config.setDeviceName("iFly");// 设备名称
        if (packageType.getValue().contains("pad")) {
            config.setTerminalType(com.companyName.protocol.enums.TerminalType.APAD);
        } else {
            config.setTerminalType(com.companyName.protocol.enums.TerminalType.APHONE);
        }
        // config.setTtl(1200 * 1000);// 发起端指定的会话生存期，单位毫秒，超过这个时间仍无通讯则认为到接收端的连接断开
        // 默认12*1000毫秒
        // 当Integer.MAX_VALUE为不启动
//        String userName = (String) MySharePerfance.getInstance(this).getValue("_userName", "String");
//        String userCode = (String) MySharePerfance.getInstance(this).getValue("_userCode", "String");
//        userName = "test2";
//        userCode = "userCode";
//        config.setMesClientUserName("userName");
//        config.setMesClientPassword("userCode");
//        config.setMesUserIp("172.21.11.121");
//        config.setMesUserPORT(9999);
//        config.setMesScanOnlineFriendsAddr("http://172.21.11.121:8080");
        
        Client.setConfig(config);
        Client.getInstance().setOnDeviceChangedListener(this);
        Client.getInstance().setOnDeviceSearchListener(this);
        Client.getInstance().searchDeviceWithTimeout(FlyConstant.CLIENT_TIME_OUT, true);
    }

    public void idfConfig() {
        PreferencesHelper helper = new PreferencesHelper(this, "serverAddr");
        String msisAddr = helper.getValue("msisServerAddr", getString(R.string.msis_server_addr));
        String userAddr = helper.getValue("userCenterServerAddr",
                getString(R.string.usercenter_server_addr));
        IDFServiceAgentConfig agentConfig = IDFServiceAgentConfig.getInstance();
        agentConfig.setContext(getApplicationContext());
        agentConfig.setOpenHint(true);
        agentConfig.setMsisServerAddr(msisAddr);
        agentConfig.setUserCenterServerAddr(userAddr);
        agentConfig.setVersion("V001");
        if (packageType.getValue().contains("pad")) {
            agentConfig.setTerminalType(TerminalType.PAD);
        } else {
            agentConfig.setTerminalType(TerminalType.PHONE);
        }
        agentConfig.setTimeout(30 * 1000);
        agentConfig.setResolution(width + "*" + height);// "1280*720"
        agentConfig.setZip(true);
        // 外网权限: 1点播、2直播、3回看、 4时移
        agentConfig.addExtranetAuthSet("1");
        agentConfig.addExtranetAuthSet("2");
        agentConfig.addExtranetAuthSet("3");
        agentConfig.addExtranetAuthSet("4");
        agentConfig.setSqLiteDatabase(mdba.mSQLiteDatabase);
        agentConfig.addCacheUrls(InterfaceUrls.QUERY_USERINFO);
        agentConfig.addCacheUrls(InterfaceUrls.GET_CHANNELBRAND_INFO);
        agentConfig.addCacheUrls(InterfaceUrls.GET_RECOMMEND_RESOURCE);
        agentConfig.addCacheUrls(InterfaceUrls.GET_ASSETDETAIL);
        /** 3.1.4 获取栏目列表 */
        agentConfig.addCacheUrls(InterfaceUrls.GET_CATALOG);
        agentConfig.addCacheUrls(InterfaceUrls.GET_ASSET_LIST);

        agentConfig.addCacheUrls(InterfaceUrls.GET_PRAM);
        agentConfig.addCacheUrls(InterfaceUrls.GET_CHANNELS);
        initImageLoader(getApplicationContext());

        initBitStates();
    }

    /**
     * 获得当前设备的飞飞看连接状态 ，在onDeviceChanged里改变这个全局的状态
     *
     * @return
     */
    public ConnectionStatus getmConnectionStatus() {
        return mConnectionStatus;
    }

    public void gotoUserLoginDialog(final Activity context) {
        Intent loginIntent = new Intent();
        loginIntent.setAction(getString(R.string.activity_userlogin));
        loginIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        loginIntent.putExtra("StartFrom", "Player");
        context.startActivity(loginIntent);
    }

    public Map<String, AssetListInfo> getUserFavourite() {
        return userFavourite;
    }

    public void setUserFavourite(Map<String, AssetListInfo> userFavourite) {
        this.userFavourite = userFavourite;
    }

    public TreeMap<String, ChannelInfo> getMyFavouriteChannels() {
        return myFavouriteChannels;
    }

    public void setMyFavouriteChannels(TreeMap<String, ChannelInfo> myFavouriteChannels) {
        this.myFavouriteChannels = myFavouriteChannels;
    }

    @Override
    public void onDeviceChanged(IDFDevice idfDevice) {
        if (null != MyApplication.eventBus) {
            IDFLog.d("设备发生改变时的回调函数" + idfDevice.getDeviceName());
            // 设备发生改变时的回调函数
            MyApplication.eventBus.post(new EventAction(EventAction.ACTION_DEVICE_CHANGED,
                    idfDevice));
        }
    }

    /** 搜索设备开始时的回调函数 */
    @Override
    public void onSearchStart() {
        if (null != MyApplication.eventBus) {
            IDFLog.d("搜索设备开始时的回调函数");
            MyApplication.eventBus.post(new EventAction(EventAction.ACTION_SEARCH_START, null));
        }
    }

    /** 搜索到一个设备成功后的回调函数 */
    @Override
    public void onDeviceOnline(IDFDevice idfDevice) {
        if (null != MyApplication.eventBus) {
            IDFLog.d("搜索到一个设备成功后的回调函数" + idfDevice.getHost());
            MyApplication.eventBus
                    .post(new EventAction(EventAction.ACTION_DEVICE_ONLINE, idfDevice));
        }
    }

    /** 搜索设备完成时的回调函数 */
    @Override
    public void onSearchEnd() {
        if (null != MyApplication.eventBus) {
            IDFLog.d("搜索设备完成时的回调函数");
            // IDFToast.makeTextShort(mContext, "搜索设备完成时的回调函数");
            MyApplication.eventBus.post(new EventAction(EventAction.ACTION_SEARCH_END, null));
        }
    }

    /**
     * 账号重复登陆提示框。
     */
    public void showExitDialog(String opt) {
        Session.getInstance().setLogined(false);
        Session.getInstance().setUserCode(null);
        if (aDialog != null && aDialog.isShowing()) {
            return;
        }
        AlertDialog.Builder builder = new AlertDialog.Builder(this)
                .setTitle(R.string.exit_tip)
                .setCancelable(false)
                .setMessage(opt)
                .setPositiveButton(getString(R.string.exit_btn_message),
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int which) {
                                /* 退出登录 */
                                for (int i = 0; i < ActivityManager.getScreenManager().getSize(); i++) {
                                    Activity act = ActivityManager.getScreenManager().getItem(i);
                                    if (act != null) {
                                        act.finish();
                                    }
                                }
                                ActivityManager.getScreenManager().clear();

                                System.exit(0);
                                android.os.Process.killProcess(android.os.Process.myPid());
                            }
                        });
        aDialog = builder.create();
        aDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);//
        aDialog.show();
    }

    /***
     * 获取所有的栏目ID <一句话功能简述> <功能详细描述> [参数说明]
     */
    private AsyncTask getCatalog(int catalogType, final int parentId) {
        Session session = Session.getInstance();
        GetCatalogParameters parameters = new GetCatalogParameters();
        parameters.setCatalogType(catalogType);
        parameters.setParentId(parentId);
        parameters.setUserCode(session.getUserCode());
        parameters.setAccessSource(5);

        return IDFMsisAgent.getInstance().getCatalog(parameters, new RequestListener() {

            @Override
            public void onComplete(BaseJsonBean baseJsonBean) {
                if (baseJsonBean != null) {
                    if (baseJsonBean != null && 0 == baseJsonBean.getRet()) {
                        CatalogJson result = (CatalogJson) baseJsonBean;

                        if (null != result) {
                            if (parentId == 0) {
                                List<Catalog> recommendCatalogs = result.getCatalog();

                                /** 加载不同的推荐栏目 */
                                for (int index = 0, len = recommendCatalogs.size(); index < len; index++) {
                                    Catalog recommendCatalog = recommendCatalogs.get(index);
                                    if (null != recommendCatalog) {
                                        IDFManager.getSpecificCatalogResources(null, null, index,
                                                recommendCatalog.getColumnID());

                                    }
                                }
                            }
                        }
                    }
                }
            }

        });
    }
}