MyApplication

约定不等于承诺〃 2022-08-20 07:24 3阅读 0赞

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());  
  
                                    \}  
                                \}  
                            \}  
                        \}  
                    \}  
                \}  
            \}  
  
        \});  
    \}  
\}

MyApplication

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 MyApplication

相关 Android Studio之提示Unable to delete directory ‘*****\MyApplication\app\build‘