【移动开发】Android中WIFI开发总结（二）-低调大师

【移动开发】Android中WIFI开发总结（二）

2017-11-07 625

搞了好几天终于有点眉目了，这里接着总结一下Android中WiFi的使用，在前面（http://smallwoniu.blog.51cto.com/3911954/1334951）我们已经简单了解了Wifi实际操作中所用到的几个主要类，今天就剖析一个WIFI搜索、创建、关闭、连接及一些简单的动画的综合案例。

首先，我们还是看一下我们项目的框架

MainActivity类：（处理wifi消息，加载UI）

 
        /**
       
        * 主界面 
       
        * @author ZHF 
       
        * 
       
        */ 
       
        public 
        class 
        MainActivity 
        extends 
        Activity 
        implements 
        EventHandler{ 
       
        //消息事件 
       
        public 
        static 
        final 
        int 
        m_nWifiSearchTimeOut = 
        0
        ;
        // 搜索超时 
       
        public 
        static 
        final 
        int 
        m_nWTScanResult = 
        1
        ;
        // 搜索到wifi返回结果 
       
        public 
        static 
        final 
        int 
        m_nWTConnectResult = 
        2
        ;
        // 连接上wifi热点 
       
        public 
        static 
        final 
        int 
        m_nCreateAPResult = 
        3
        ;
        // 创建热点结果 
       
        public 
        static 
        final 
        int 
        m_nUserResult = 
        4
        ;
        // 用户上线人数更新命令(待定) 
       
        public 
        static 
        final 
        int 
        m_nWTConnected = 
        5
        ;
        // 点击连接后断开wifi，3.5秒后刷新adapter 
       
        //一些常量 
       
        public 
        static 
        final 
        String PACKAGE_NAME = 
        "com.zhf.wifidemo.wifi"
        ;  
        //应用包名 
       
        public 
        static 
        final 
        String FIRST_OPEN_KEY = 
        "version"
        ;  
        //版本号信息 
       
        public 
        static 
        final 
        String WIFI_AP_HEADER = 
        "zhf_"
        ; 
       
        public 
        static 
        final 
        String WIFI_AP_PASSWORD =
        "zhf12345"
        ; 
       
        //wifi操作事件（枚举）-->方便弹出对话框处理事件 
       
        private 
        int 
        wFOperateEnum = WFOperateEnum.NOTHING; 
       
        //三个重要的类 
       
        public 
        WFSearchProcess m_wtSearchProcess; 
        //WiFi搜索进度条线程 
       
        public 
        WifiAdmin m_wiFiAdmin; 
        //Wifi管理类 
       
        public 
        CreateAPProcess m_createAPProcess; 
        //创建Wifi热点线程 
       
        //相关控件 
       
        private 
        WFSearchAnimationFrameLayout m_FrameLWTSearchAnimation;  
        //自定义雷达动画布局 
       
        private 
        GifView m_gifRadar;  
        //wifi信号动画布局 
       
        private 
        LinearLayout m_linearLCreateAP; 
        //创建热点View 
       
        private 
        ProgressBar m_progBarCreatingAP; 
        //创建热点进度条 
       
        private 
        TextView m_textVPromptAP; 
        //创建热点进度条文字 
       
        private 
        Button m_btnBack; 
        //左上角返回按钮 
       
        private 
        Button m_btnSearchWF; 
        //右上角wifi搜索按钮 
       
        private 
        Button m_btnCreateWF; 
        //创建wifi热点 
       
        private 
        ListView m_listVWT; 
        //显示信息 
       
        private 
        LinearLayout m_LinearLDialog; 
        //提醒对话框 
       
        private 
        TextView m_textVContentDialog;  
        //对话框文本内容 
       
        private 
        Button m_btnConfirmDialog, m_btnCancelDialog; 
        //提醒对话框上的按钮 
       
        private 
        TextView m_textVWTPrompt; 
        //中间文字提示 
       
        private 
        boolean 
        m_isFirstOpen = 
        true
        ;  
        //标记是否是第一次打开 
       
        ArrayList<ScanResult> m_listWifi = 
        new 
        ArrayList();
        //检测到热点信息列表 
       
        private 
        WTAdapter m_wTAdapter; 
        //网络列表适配器 
       
        public 
        Handler mHandler = 
        new 
        Handler() { 
       
        public 
        void 
        handleMessage(android.os.Message msg) { 
       
        switch 
        (msg.what) { 
       
        case 
        m_nWifiSearchTimeOut: 
        // 搜索超时 
       
        m_wtSearchProcess.stop(); 
       
        m_FrameLWTSearchAnimation.stopAnimation(); 
       
        m_listWifi.clear();  
        //网络列表 
       
        //设置控件 
       
        m_textVWTPrompt.setVisibility(View.VISIBLE); 
       
        m_textVWTPrompt.setText(
        "需要重新搜索，点右上角重新搜索或创建新的热点..."
        ); 
       
        break
        ; 
       
        case 
        m_nWTScanResult:  
        //扫描到结果 
       
        m_listWifi.clear(); 
       
        if
        (m_wiFiAdmin.mWifiManager.getScanResults() != 
        null
        ) { 
       
        for 
        (
        int 
        i = 
        0
        ; i < m_wiFiAdmin.mWifiManager.getScanResults().size(); i++) { 
       
        ScanResult scanResult = m_wiFiAdmin.mWifiManager.getScanResults().get(i); 
       
        //和指定连接热点比较，将其他的过滤掉！ 
       
        if
        (scanResult.SSID.startsWith(WIFI_AP_HEADER)) { 
       
        m_listWifi.add(scanResult); 
       
        } 
       
        } 
       
        if
        (m_listWifi.size() > 
        0
        ) { 
       
        m_wtSearchProcess.stop(); 
       
        m_FrameLWTSearchAnimation.stopAnimation(); 
       
        m_textVWTPrompt.setVisibility(View.GONE); 
       
        //更新列表，显示出搜索到的热点 
       
        m_wTAdapter.setData(m_listWifi); 
       
        m_wTAdapter.notifyDataSetChanged(); 
       
        } 
       
        } 
       
        break
        ; 
       
        case 
        m_nWTConnectResult:  
        //连接结果 
       
        m_wTAdapter.notifyDataSetChanged(); 
        //刷新适配器数据 
       
        break
        ; 
       
        case 
        m_nCreateAPResult:  
        //创建wifi热点结果 
       
        m_createAPProcess.stop(); 
       
        m_progBarCreatingAP.setVisibility(View.GONE); 
        //旋转进度条 
       
        if
        ((m_wiFiAdmin.getWifiApState() == 
        3 
        || m_wiFiAdmin.getWifiApState() == 
        13
        ) && (m_wiFiAdmin.getApSSID().startsWith(WIFI_AP_HEADER))) { 
       
        //设置控件 
       
        m_textVWTPrompt.setVisibility(View.GONE); 
       
        m_linearLCreateAP.setVisibility(View.VISIBLE); 
       
        m_btnCreateWF.setVisibility(View.VISIBLE); 
       
        m_gifRadar.setVisibility(View.VISIBLE); 
       
        m_btnCreateWF.setBackgroundResource(R.drawable.x_ap_close); 
       
        m_textVPromptAP.setText(
        "热点创建成功！"
        + 
        "\n热点名："
        + m_wiFiAdmin.getApSSID()+ 
        "\n连接密码：zhf12345"
        ); 
       
        } 
        else 
        { 
       
        m_btnCreateWF.setVisibility(View.VISIBLE); 
       
        m_btnCreateWF.setBackgroundResource(R.drawable.x_wt_create); 
       
        m_textVPromptAP.setText(
        "热点创建失败，您可以重新创建或者搜索其它热点"
        ); 
       
        } 
       
        break
        ; 
       
        case 
        m_nUserResult : 
       
        //更新用户上线人数 
       
        break
        ; 
       
        case 
        m_nWTConnected:  
        //点击连接后断开wifi，3.5s后刷新 
       
        m_wTAdapter.notifyDataSetChanged(); 
       
        break
        ; 
       
        } 
       
        }; 
       
        }; 
       
        @Override 
       
        public 
        void 
        onCreate(Bundle savedInstanceState) { 
       
        super
        .onCreate(savedInstanceState); 
       
        setContentView(R.layout.wt_main); 
       
        //搜索Wifi 
       
        m_wtSearchProcess = 
        new 
        WFSearchProcess(
        this
        ); 
       
        //创建Wifi热点 
       
        m_createAPProcess = 
        new 
        CreateAPProcess(
        this
        ); 
       
        //wifi管理类 
       
        m_wiFiAdmin  = WifiAdmin.getInstance(
        this
        ); 
       
        //初始化View 
       
        initView(); 
       
        } 
       
        /**初始化View**/ 
       
        private 
        void 
        initView() { 
       
        // 监听广播 
       
        WIFIBroadcast.ehList.add(
        this
        ); 
       
        /******************************实例化布局**************************************/ 
       
        m_linearLCreateAP = (LinearLayout) findViewById(R.id.create_ap_llayout_wt_main);  
        //创建热点View 
       
        m_progBarCreatingAP = (ProgressBar) findViewById(R.id.creating_progressBar_wt_main);  
        //创建热点进度条 
       
        m_textVPromptAP = (TextView) findViewById(R.id.prompt_ap_text_wt_main); 
        //创建热点进度条文字 
       
        m_FrameLWTSearchAnimation = ((WFSearchAnimationFrameLayout) findViewById(R.id.search_animation_wt_main));
        // 搜索时的动画 
       
        m_listVWT = ((ListView) findViewById(R.id.wt_list_wt_main));
        // 搜索到的热点listView 
       
        //注意此处 
       
        m_wTAdapter = 
        new 
        WTAdapter(
        this
        , m_listWifi); 
       
        m_listVWT.setAdapter(m_wTAdapter); 
       
        m_textVWTPrompt = (TextView) findViewById(R.id.wt_prompt_wt_main); 
        //中间提醒文字 
       
        m_gifRadar = (GifView) findViewById(R.id.radar_gif_wt_main); 
        //gif动画 
       
        //提醒对话框布局 
       
        m_LinearLDialog = (LinearLayout) findViewById(R.id.dialog_layout_wt_main); 
       
        m_textVContentDialog = (TextView) findViewById(R.id.content_text_wtdialog); 
       
        m_btnConfirmDialog = (Button) findViewById(R.id.confirm_btn_wtdialog); 
       
        m_btnCancelDialog = (Button) findViewById(R.id.cancel_btn_wtdialog); 
       
        //左上角返回键 
       
        m_btnBack = (Button) findViewById(R.id.back_btn_wt_main); 
       
        m_btnBack.setOnClickListener(
        new 
        OnClickListener() { 
       
        @Override 
       
        public 
        void 
        onClick(View v) { 
       
        onBackPressed(); 
        //相当于调用系统返回键，结束当前Activity 
       
        } 
       
        }); 
       
        //右上角搜索热点按钮 
       
        m_btnSearchWF = (Button) findViewById(R.id.search_btn_wt_main); 
       
        m_btnSearchWF.setOnClickListener(
        new 
        OnClickListener() { 
       
        @Override 
       
        public 
        void 
        onClick(View v) { 
       
        if
        (!m_wtSearchProcess.running) { 
        //搜索线程没有开启 
       
        //1.当前热点或wifi连接着    WIFI_STATE_ENABLED 3 //WIFI_AP_STATE_ENABLED  13 
       
        if
        (m_wiFiAdmin.getWifiApState() == 
        3 
        || m_wiFiAdmin.getWifiApState() == 
        13
        ) { 
       
        wFOperateEnum = WFOperateEnum.SEARCH; 
        //搜索wifi事件 
       
        m_LinearLDialog.setVisibility(View.VISIBLE); 
        ///wifi提示对话框显示 
       
        m_textVContentDialog.setText(
        "是否关闭当前热点去搜索其他热点？"
        ); 
       
        return
        ;  
        //跳出此方法，交由对话框来处理事件 
       
        } 
       
        //2.当前没有热点或wifi连接着 
       
        if
        (!m_wiFiAdmin.mWifiManager.isWifiEnabled()) { 
        //如果wifi没打开 
       
        m_wiFiAdmin.OpenWifi(); 
       
        } 
       
        m_textVWTPrompt.setVisibility(View.VISIBLE); 
        //中间提示文字 
       
        m_textVWTPrompt.setText(
        "正在搜索附近的热点..."
        ); 
       
        m_linearLCreateAP.setVisibility(View.GONE); 
        //创建wifi热点布局消失 
       
        m_gifRadar.setVisibility(View.GONE); 
        //热点连接动画消失 
       
        m_btnCreateWF.setBackgroundResource(R.drawable.x_wt_create); 
        //更改按钮文字“创建” 
       
        //开始搜索wifi 
       
        m_wiFiAdmin.startScan(); 
       
        m_wtSearchProcess.start(); 
        //开启搜索线程 
       
        m_FrameLWTSearchAnimation.startAnimation(); 
        //开启波纹动画 
       
        }
        else 
        {
        //搜索线程开启着，再次点击按钮 
       
        //重新启动 
       
        m_wtSearchProcess.stop(); 
       
        m_wiFiAdmin.startScan();    
        //开始搜索wifi 
       
        m_wtSearchProcess.start(); 
       
        } 
       
        } 
       
        }); 
       
        //中间创建wifi热点按钮 
       
        m_btnCreateWF = (Button) findViewById(R.id.create_btn_wt_main); 
       
        m_btnCreateWF.setOnClickListener(
        new 
        OnClickListener() { 
       
        @Override 
       
        public 
        void 
        onClick(View v) { 
       
        if
        (m_wiFiAdmin.getWifiApState() == 
        4
        ) { 
        // WIFI_STATE_UNKNOWN 
       
        Toast.makeText(getApplicationContext(),
        "您的设备不支持热点创建!"
        , Toast.LENGTH_SHORT).show(); 
       
        return
        ; 
       
        } 
       
        if
        (m_wiFiAdmin.mWifiManager.isWifiEnabled()) { 
        //目前连着wifi 
       
        wFOperateEnum = WFOperateEnum.CREATE;  
        //wifi热点创建事件 
       
        m_LinearLDialog.setVisibility(View.VISIBLE); 
        //对话框可用 
       
        m_textVContentDialog.setText(
        "创建热点会关闭当前的WiFi，确认继续？"
        ); 
       
        return
        ; 
       
        } 
       
        if
        ((m_wiFiAdmin.getWifiApState() == 
        3 
        || m_wiFiAdmin.getWifiApState() == 
        13
        ) 
       
        && (!m_wiFiAdmin.getApSSID().startsWith(WIFI_AP_HEADER))) {
        //目前连接着其他热点名 
       
        wFOperateEnum = WFOperateEnum.CREATE;  
        //wifi热点创建事件 
       
        m_LinearLDialog.setVisibility(View.VISIBLE); 
       
        m_textVContentDialog.setText(
        "系统热点被占用，点确定开启热点以传输文件！"
        ); 
       
        return
        ; 
       
        } 
       
        if 
        (((m_wiFiAdmin.getWifiApState() == 
        3
        ) || (m_wiFiAdmin.getWifiApState() == 
        13
        )) 
       
        && (m_wiFiAdmin.getApSSID().startsWith(WIFI_AP_HEADER))) {
        //目前连接着自己指定的Wifi热点 
       
        wFOperateEnum = WFOperateEnum.CLOSE;  
        //wifi热点关闭事件 
       
        m_LinearLDialog.setVisibility(View.VISIBLE); 
       
        m_textVContentDialog.setText(
        "关闭热点会中断当前传输，您确定这么做？"
        ); 
       
        return
        ; 
       
        } 
       
        if
        (m_wtSearchProcess.running) { 
       
        m_wtSearchProcess.stop(); 
        //停止线程 
       
        m_FrameLWTSearchAnimation.stopAnimation(); 
        //停止动画 
       
        } 
       
        /******************点击创建热点时没有连接wifi或热点的情况*****************************/ 
       
        //关闭Wifi 
       
        m_wiFiAdmin.closeWifi(); 
       
        //创建热点（名字，密码，加密类型,wifi/ap类型） 
       
        m_wiFiAdmin.createWifiAP(m_wiFiAdmin.createWifiInfo(WIFI_AP_HEADER + getLocalHostName(), WIFI_AP_PASSWORD, 
        3
        , 
        "ap"
        ), 
        true
        ); 
       
        m_createAPProcess.start(); 
        //开启创建热点线程 
       
        //将wifi信息列表设置到listview中 
       
        m_listWifi.clear(); 
       
        m_wTAdapter.setData(m_listWifi); 
       
        m_wTAdapter.notifyDataSetChanged(); 
       
        //设置布局 
       
        m_linearLCreateAP.setVisibility(View.VISIBLE); 
        //热点布局可用 
       
        m_progBarCreatingAP.setVisibility(View.VISIBLE); 
       
        m_textVPromptAP.setText(
        "正在创建热点"
        ); 
        //进度条文字 
       
        m_btnCreateWF.setVisibility(View.GONE); 
        //点击一次不可再点 
       
        m_textVWTPrompt.setVisibility(View.GONE); 
       
        } 
       
        }); 
       
        //对话框确认按钮 
       
        m_btnConfirmDialog.setOnClickListener(
        new 
        OnClickListener() { 
       
        @Override 
       
        public 
        void 
        onClick(View v) { 
       
        m_LinearLDialog.setVisibility(View.GONE); 
        //让对话框布局消失 
       
        switch 
        (wFOperateEnum) { 
        //根据wifi操作事件 
       
        case 
        WFOperateEnum.CLOSE:  
        //关闭wifi热点 
       
        //设置布局 
       
        m_textVWTPrompt.setVisibility(View.VISIBLE); 
       
        m_textVWTPrompt.setText(
        "热点已关闭！可以进行其他操作了！"
        ); 
        //中间提醒文字 
       
        m_btnCreateWF.setBackgroundResource(R.drawable.x_wt_create); 
        //按钮文字改回“创建” 
       
        m_gifRadar.setVisibility(View.GONE); 
        //热点动画停止 
       
        m_linearLCreateAP.setVisibility(View.GONE); 
        //下部创建热点布局不可用 
       
        //关闭热点 
       
        m_wiFiAdmin.createWifiAP(m_wiFiAdmin.createWifiInfo(m_wiFiAdmin.getApSSID(), 
        "zhf123456"
        , 
        3
        , 
        "ap"
        ), 
        false
        ); 
       
        break
        ; 
       
        case 
        WFOperateEnum.CREATE:  
        //创建wifi热点 
       
        if
        (m_wtSearchProcess.running) { 
       
        m_wtSearchProcess.stop();  
        //搜索wifi线程停止 
       
        m_FrameLWTSearchAnimation.stopAnimation(); 
        //搜索wifi动画停止 
       
        } 
       
        //关闭wifi 
       
        m_wiFiAdmin.closeWifi(); 
       
        //创建WiFi热点 
       
        m_wiFiAdmin.createWifiAP(m_wiFiAdmin.createWifiInfo(WIFI_AP_HEADER + getLocalHostName(), WIFI_AP_PASSWORD, 
        3
        , 
        "ap"
        ),
        true
        ); 
       
        m_createAPProcess.start(); 
       
        //刷新listView布局 
       
        m_listWifi.clear(); 
       
        m_wTAdapter.setData(m_listWifi); 
       
        m_wTAdapter.notifyDataSetChanged(); 
       
        //设置布局 
       
        m_linearLCreateAP.setVisibility(View.VISIBLE); 
       
        m_progBarCreatingAP.setVisibility(View.VISIBLE); 
        //旋转进度条 
       
        m_btnCreateWF.setVisibility(View.GONE); 
       
        m_textVWTPrompt.setVisibility(View.GONE); 
       
        m_textVPromptAP.setText(
        "正在创建热点..."
        ); 
        //进度条文字 
       
        break
        ; 
       
        case 
        WFOperateEnum.SEARCH:  
        //搜索可用热点 
       
        //设置布局 
       
        m_textVWTPrompt.setVisibility(View.VISIBLE); 
       
        m_textVWTPrompt.setText(
        "正在搜索附近的热点..."
        ); 
       
        m_linearLCreateAP.setVisibility(View.GONE); 
        //创建热点布局不可用 
       
        m_btnCreateWF.setVisibility(View.VISIBLE); 
       
        m_btnCreateWF.setBackgroundResource(R.drawable.x_wt_create); 
        //按钮文字改回“创建” 
       
        m_gifRadar.setVisibility(View.GONE); 
        //热点动画停止 
       
        m_linearLCreateAP.setVisibility(View.GONE); 
        //下部创建热点布局不可用 
       
        //搜索热点线程关闭 
       
        if 
        (m_createAPProcess.running) 
       
        m_createAPProcess.stop(); 
       
        //关闭热点 
       
        m_wiFiAdmin.createWifiAP(m_wiFiAdmin.createWifiInfo(m_wiFiAdmin.getApSSID(), WIFI_AP_PASSWORD, 
        3
        , 
        "ap"
        ),
        false
        ); 
       
        //打开wifi 
       
        m_wiFiAdmin.OpenWifi(); 
       
        m_wtSearchProcess.start(); 
       
        m_FrameLWTSearchAnimation.startAnimation(); 
       
        break
        ; 
       
        } 
       
        } 
       
        }); 
       
        //对话框取消按钮事件 
       
        m_btnCancelDialog.setOnClickListener(
        new 
        OnClickListener() { 
       
        @Override 
       
        public 
        void 
        onClick(View v) { 
       
        //对话框布局消失 
       
        m_LinearLDialog.setVisibility(View.GONE); 
       
        } 
       
        }); 
       
        } 
       
        /**Wifi是否连接**/ 
       
        private 
        boolean 
        isWifiConnect() { 
       
        boolean 
        isConnect = 
        true
        ; 
       
        //用于网络连接状态的检测 
       
        ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); 
       
        if
        (!cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnected()) 
       
        isConnect = 
        false
        ; 
       
        return 
        isConnect; 
       
        } 
       
        /**获取wifi热点状态**/ 
       
        public 
        boolean 
        getWifiApState() { 
       
        try 
        { 
       
        WifiManager localWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); 
       
        Method m = localWifiManager.getClass().getMethod(
        "getWifiApState"
        , 
        new 
        Class[
        0
        ]); 
       
        int 
        i = (Integer)(m.invoke(localWifiManager, 
        new 
        Object[
        0
        ])); 
       
        return 
        (
        3 
        == i) || (
        13 
        == i);  
        //WIFI_STATE_ENABLED 3  //WIFI_AP_STATE_ENABLED  13 
       
        } 
        catch 
        (Exception e) { 
       
        e.printStackTrace(); 
       
        } 
       
        return 
        false
        ; 
       
        } 
       
        /**获取手机信息**/ 
       
        public 
        String getLocalHostName() { 
       
        String str1 = Build.BRAND; 
        //主板 
       
        String str2 = Build.MODEL;  
        //机型 
       
        if 
        (-
        1 
        == str2.toUpperCase().indexOf(str1.toUpperCase())) 
       
        str2 = str1 + 
        "_" 
        + str2; 
       
        return 
        str2; 
       
        } 
       
        private 
        void 
        init() { 
       
        //线程是否在运行 
       
        if
        (
        this
        .m_wtSearchProcess.running || 
        this
        .m_createAPProcess.running) { 
       
        return
        ; 
       
        } 
       
        //没有连接上wifi或者是wifi热点 
       
        if
        (!isWifiConnect() && !getWifiApState()) { 
       
        m_wiFiAdmin.OpenWifi(); 
       
        m_wtSearchProcess.start(); 
        //开启搜索wifi超时检测线程 
       
        m_wiFiAdmin.startScan(); 
        //开启搜索wifi 
       
        //开启搜索动画 
       
        m_FrameLWTSearchAnimation.startAnimation(); 
       
        //设置控件 
       
        m_textVWTPrompt.setVisibility(View.VISIBLE); 
       
        m_textVWTPrompt.setText(
        " 正在搜索附近的热点..."
        ); 
       
        m_linearLCreateAP.setVisibility(View.GONE); 
       
        m_btnCreateWF.setBackgroundResource(R.drawable.x_wt_create); 
       
        } 
       
        //连接上wifi 
       
        if
        (isWifiConnect()) { 
       
        this
        .m_wiFiAdmin.startScan(); 
       
        this
        .m_wtSearchProcess.start(); 
       
        this
        .m_FrameLWTSearchAnimation.startAnimation(); 
       
        //设置控件 
       
        this
        .m_textVWTPrompt.setVisibility(
        0
        ); 
       
        this
        .m_textVWTPrompt.setText(
        "正在搜索附近的热点..."
        ); 
       
        this
        .m_linearLCreateAP.setVisibility(View.GONE); 
       
        this
        .m_btnCreateWF.setBackgroundResource(R.drawable.x_wt_create); 
       
        this
        .m_gifRadar.setVisibility(View.GONE); 
       
        m_listWifi.clear(); 
       
        if
        (m_wiFiAdmin.mWifiManager.getScanResults() != 
        null
        ) { 
       
        for 
        (
        int 
        i = 
        0
        ; i < m_wiFiAdmin.mWifiManager.getScanResults().size(); i++) { 
       
        //识别出自己自定连接的wifi 
       
        if
        (m_wiFiAdmin.mWifiManager.getScanResults().get(i).SSID.startsWith(WIFI_AP_HEADER)) { 
       
        m_listWifi.add(m_wiFiAdmin.mWifiManager.getScanResults().get(i)); 
        //将指定wifi添加进去 
       
        } 
       
        } 
       
        m_wTAdapter.setData(m_listWifi); 
        //将连接的信息添加到listView中 
       
        m_wTAdapter.notifyDataSetChanged(); 
       
        } 
       
        //连接上wifi热点 
       
        if
        (getWifiApState()){ 
       
        if
        (m_wiFiAdmin.getApSSID().startsWith(WIFI_AP_HEADER)) { 
       
        //设置控件 
       
        m_textVWTPrompt.setVisibility(View.GONE); 
       
        m_linearLCreateAP.setVisibility(View.VISIBLE); 
       
        m_progBarCreatingAP.setVisibility(View.GONE); 
       
        m_btnCreateWF.setVisibility(View.VISIBLE); 
       
        m_gifRadar.setVisibility(View.VISIBLE); 
       
        m_btnCreateWF.setBackgroundResource(R.drawable.x_ap_close); 
       
        m_textVPromptAP.setText(
        "\n热点名："
        + m_wiFiAdmin.getApSSID() + 
        "\n连接密码：zhf12345"
        ); 
       
        } 
       
        } 
       
        } 
       
        } 
       
        @Override 
       
        protected 
        void 
        onDestroy() { 
       
        // TODO Auto-generated method stub 
       
        super
        .onDestroy(); 
       
        WIFIBroadcast.ehList.remove(
        this
        ); 
       
        } 
       
        @Override 
       
        public 
        void 
        handleConnectChange() { 
       
        Message msg = mHandler.obtainMessage(m_nWTConnectResult); 
       
        mHandler.sendMessage(msg); 
       
        } 
       
        @Override 
       
        public 
        void 
        scanResultsAvaiable() { 
       
        Message msg = mHandler.obtainMessage(m_nWTScanResult); 
       
        mHandler.sendMessage(msg); 
       
        } 
       
        @Override 
       
        public 
        void 
        wifiStatusNotification() { 
       
        m_wiFiAdmin.mWifiManager.getWifiState(); 
        //获取当前wifi状态 
       
        } 
       
        }

貌似有点长。。。简单说明一下：

1.首先，初始化主界面（xml有些复杂，慢慢理一下就好了，不是什么大问题）接下来，处理三个重要的按钮事件：右上角的搜索wifi按钮、中间创建或关闭热点按钮、对话框中确定按钮。处理前两者事件时，需关注当前wifi状态，若为占用，需弹出提醒对话框来根据当前WiFi操作（WFOperateEnum类中定义好了）事件，来创建、关闭、搜索等具体事务。

2.之所以定义广播接收者，是为了监听当wifi状态发生变化时，能够及时更新界面

广播接收者WIFIBroadcast类:

 
        package 
        com.zhf.wifidemo.broadcast; 
       
        import 
        java.util.ArrayList; 
       
        import 
        android.content.BroadcastReceiver; 
       
        import 
        android.content.Context; 
       
        import 
        android.content.Intent; 
       
        import 
        android.net.wifi.WifiManager; 
       
        import 
        android.util.Log; 
       
        /**
       
        * 监听wifi热点变化 
       
        * @author ZHF 
       
        * 
       
        */ 
       
        public 
        class 
        WIFIBroadcast 
        extends 
        BroadcastReceiver{ 
       
        public 
        static 
        ArrayList<EventHandler> ehList = 
        new 
        ArrayList<EventHandler>(); 
       
        @Override 
       
        public 
        void 
        onReceive(Context context, Intent intent) { 
       
        //搜索到wifi热点结果的广播:  "android.net.wifi.SCAN_RESULTS" 
       
        if
        (intent.getAction().endsWith(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) { 
       
        Log.i(
        "WTScanResults---->扫描到了可用网络---->"
        , 
        "android.net.wifi.SCAN_RESULTS"
        ); 
       
        //遍历通知各个监听接口 
       
        for
        (
        int 
        i = 
        0
        ; i < ehList.size(); i++) { 
       
        ((EventHandler)ehList.get(i)).scanResultsAvaiable(); 
       
        } 
       
        //wifi打开或关闭状态变化   "android.net.wifi.WIFI_STATE_CHANGED" 
       
        }
        else 
        if
        (intent.getAction().endsWith(WifiManager.WIFI_STATE_CHANGED_ACTION)) { 
       
        Log.i(
        "WTScanResults----->wifi状态变化--->"
        , 
        "android.net.wifi.WIFI_STATE_CHANGED"
        ); 
       
        //这里不需要连接一个SSID（wifi名称） 
       
        for
        (
        int 
        j = 
        0
        ; j < ehList.size(); j++) { 
       
        ((EventHandler)ehList.get(j)).wifiStatusNotification(); 
       
        } 
       
        //连接上一个SSID后发出的广播，(注：与android.net.wifi.WIFI_STATE_CHANGED的区别) 
       
        }
        else 
        if
        (intent.getAction().endsWith(WifiManager.NETWORK_STATE_CHANGED_ACTION)) { 
       
        Log.i(
        "WTScanResults----->网络状态变化---->"
        , 
        "android.net.wifi.STATE_CHANGE"
        ); 
       
        for
        (
        int 
        m = 
        0
        ; m < ehList.size(); m++) { 
       
        ((EventHandler)ehList.get(m)).handleConnectChange(); 
       
        } 
       
        } 
       
        } 
       
        /** 
       
        * 事件监听接口 
       
        * @author ZHF 
       
        * 
       
        */ 
       
        public 
        static 
        abstract 
        interface 
        EventHandler { 
       
        /**处理连接变化事件**/ 
       
        public 
        abstract 
        void 
        handleConnectChange(); 
       
        /**扫描结果是有效事件**/ 
       
        public 
        abstract 
        void 
        scanResultsAvaiable(); 
       
        /**wifi状态变化事件**/ 
       
        public 
        abstract 
        void 
        wifiStatusNotification(); 
       
        } 
       
        }

说明：监听系统wifi状态变化，内部定义了一个事件处理接口，当wifi状态发生变化时，让其实现类去发送消息更新界面。

CreateAPProcess类：

 
        package 
        com.zhf.wifidemo.ui; 
       
        import 
        android.net.wifi.WifiManager; 
       
        import 
        android.os.Message; 
       
        import 
        com.zhf.wifidemo.wifi.MainActivity; 
       
        /**
       
        * 创建Wifi热点 
       
        * @author ZHF 
       
        * 
       
        */ 
       
        public 
        class 
        CreateAPProcess 
        implements 
        Runnable{ 
       
        public 
        MainActivity context; 
       
        public 
        boolean running = 
        false
        ; 
       
        private 
        long startTime = 0L; 
       
        private 
        Thread thread = 
        null
        ; 
       
        public 
        CreateAPProcess(MainActivity context) { 
       
        super
        (); 
       
        this
        .context = context; 
       
        } 
       
        @Override 
       
        public 
        void 
        run() { 
       
        while
        (
        true
        ) { 
       
        if
        (!running)  
        return
        ; 
       
        //WIFI_STATE_ENABLED 3 
       
        //WIFI_AP_STATE_ENABLED  13 
       
        if
        ((context.m_wiFiAdmin.getWifiApState() == WifiManager.WIFI_STATE_ENABLED) 
       
        || (context.m_wiFiAdmin.getWifiApState() == 
        13
        ) 
       
        || (System.currentTimeMillis() - 
        this
        .startTime >= 30000L)){ 
       
        //wifi可用 或 热点可用 
       
        Message msg = context.mHandler.obtainMessage(context.m_nCreateAPResult); 
       
        context.mHandler.sendMessage(msg); 
       
        } 
       
        try 
        { 
       
        Thread.sleep(5L); 
       
        } 
        catch 
        (Exception e) { 
       
        e.printStackTrace(); 
       
        } 
       
        } 
       
        } 
       
        public 
        void 
        start() { 
       
        try 
        { 
       
        thread = 
        new 
        Thread(
        this
        ); 
       
        running = 
        true
        ; 
       
        startTime = System.currentTimeMillis(); 
       
        thread.start(); 
        //开启线程 
       
        } 
        catch 
        (Exception e) { 
       
        e.printStackTrace(); 
       
        } 
       
        } 
       
        public 
        void 
        stop() { 
       
        try 
        { 
       
        running = 
        false
        ; 
       
        thread = 
        null
        ; 
       
        startTime = 0L; 
       
        } 
        catch 
        (Exception e) { 
       
        // TODO: handle exception 
       
        } 
       
        } 
       
        }

其他类文件具体看源码，当创建一个热点成功后，等待其他客户端搜索

上图：

WIFIAdapte类：

 
        /**
       
        * 网络列表适配器 
       
        * @author ZHF 
       
        * 
       
        */ 
       
        public 
        class 
        WTAdapter 
        extends 
        BaseAdapter { 
       
        private 
        LayoutInflater mInflater; 
       
        private 
        List<ScanResult> mList;  
        //扫描到的网络结果列表 
       
        private 
        MainActivity mContext; 
       
        public 
        WTAdapter(MainActivity context, List<ScanResult> list) { 
       
        // TODO Auto-generated constructor stub 
       
        this
        .mContext = context; 
       
        this
        .mList = list; 
       
        this
        .mInflater = LayoutInflater.from(context); 
       
        } 
       
        //新加的一个函数，用来更新数据 
       
        public 
        void 
        setData(List<ScanResult> list) { 
       
        this
        .mList = list; 
       
        notifyDataSetChanged(); 
       
        } 
       
        @Override 
       
        public 
        int 
        getCount() { 
       
        return 
        mList.size(); 
       
        } 
       
        @Override 
       
        public 
        Object getItem(
        int 
        position) { 
       
        return 
        mList.get(position); 
       
        } 
       
        @Override 
       
        public 
        long 
        getItemId(
        int 
        position) { 
       
        return 
        position; 
       
        } 
       
        @Override 
       
        public 
        View getView(
        final 
        int 
        position, View convertView, ViewGroup parent) { 
       
        //获取点击向的扫描结果 
       
        final 
        ScanResult localScanResult = mList.get(position); 
       
        //获取wifi类 
       
        //      final WifiAdmin wifiAdmin = WifiAdmin.getInstance(mContext);
       
        final 
        WifiAdmin wifiAdmin = mContext.m_wiFiAdmin; 
       
        final 
        ViewHolder viewHolder; 
       
        if 
        (convertView == 
        null
        ) { 
       
        viewHolder = 
        new 
        ViewHolder(); 
       
        convertView = mInflater.inflate(R.layout.wtitem, 
        null
        ); 
       
        //加载布局模板控件 
       
        viewHolder.textVName = ((TextView) convertView.findViewById(R.id.name_text_wtitem)); 
       
        viewHolder.textConnect = ((TextView) convertView.findViewById(R.id.connect_text_wtitem)); 
       
        viewHolder.linearLConnectOk = ((LinearLayout) convertView.findViewById(R.id.connect_ok_layout_wtitem)); 
       
        viewHolder.progressBConnecting = ((ProgressBar) convertView.findViewById(R.id.connecting_progressBar_wtitem)); 
       
        convertView.setTag(viewHolder); 
       
        } 
        else 
        { 
       
        viewHolder = (ViewHolder) convertView.getTag(); 
       
        } 
       
        //点击连接处理事件 
       
        viewHolder.textConnect.setOnClickListener(
        new 
        OnClickListener() { 
       
        @Override 
       
        public 
        void 
        onClick(View v) { 
       
        //创建wifi网络 
       
        WifiConfiguration localWifiConfiguration = wifiAdmin.createWifiInfo(localScanResult.SSID, MainActivity.WIFI_AP_PASSWORD, 
        3
        ,
        "wt"
        ); 
       
        //添加到网络 
       
        wifiAdmin.addNetwork(localWifiConfiguration); 
       
        //"点击链接"消失，显示进度条， 
       
        viewHolder.textConnect.setVisibility(View.GONE); 
       
        viewHolder.progressBConnecting.setVisibility(View.VISIBLE); 
       
        viewHolder.linearLConnectOk.setVisibility(View.GONE); 
       
        //点击后3.5s发送消息 
       
        mContext.mHandler.sendEmptyMessageDelayed(mContext.m_nWTConnected, 3500L); 
       
        } 
       
        }); 
       
        // 点击断开处理事件 
       
        viewHolder.linearLConnectOk.setOnClickListener(
        new 
        OnClickListener() { 
       
        @Override 
       
        public 
        void 
        onClick(View v) { 
       
        //断开指定wifi热点 
       
        wifiAdmin.disconnectWifi(wifiAdmin.getWifiInfo().getNetworkId()); 
       
        //"断开连接"消失，进度条显示 
       
        viewHolder.textConnect.setVisibility(View.GONE); 
       
        viewHolder.progressBConnecting.setVisibility(View.VISIBLE); 
       
        viewHolder.linearLConnectOk.setVisibility(View.GONE); 
       
        //点击后3.5s发送消息 
       
        mContext.mHandler.sendEmptyMessageDelayed(mContext.m_nWTConnected, 3500L); 
       
        } 
       
        }); 
       
        //初始化布局 
       
        viewHolder.textConnect.setVisibility(View.GONE); 
       
        viewHolder.progressBConnecting.setVisibility(View.GONE); 
       
        viewHolder.linearLConnectOk.setVisibility(View.GONE); 
       
        viewHolder.textVName.setText(localScanResult.SSID); 
        //显示热点名称 
       
        // 正连接的wifi信息 
       
        WifiInfo localWifiInfo = wifiAdmin.getWifiInfo(); 
       
        if 
        (localWifiInfo != 
        null
        ) { 
       
        try 
        {
        //正在连接 
       
        if 
        ((localWifiInfo.getSSID() != 
        null
        )&& (localWifiInfo.getSSID().equals(localScanResult.SSID))) { 
       
        viewHolder.linearLConnectOk.setVisibility(View.VISIBLE); 
       
        return 
        convertView; 
       
        } 
       
        } 
        catch 
        (NullPointerException e) { 
       
        e.printStackTrace(); 
       
        return 
        convertView; 
       
        } 
       
        viewHolder.textConnect.setVisibility(View.VISIBLE); 
       
        } 
       
        return 
        convertView; 
       
        } 
       
        public 
        final 
        class 
        ViewHolder { 
       
        public 
        LinearLayout linearLConnectOk; 
       
        public 
        ProgressBar progressBConnecting; 
       
        public 
        TextView textConnect; 
       
        public 
        TextView textVName; 
       
        } 
       
        }

点击连接，实现客户连接，此时他们将处于同一网段内，接下来就可以自己实现传输数据，操控等一系列操作了。在下一篇中我会继实现一个基于wif热点的多人聊天室，希望能帮助到大家！

源码:http://down.51cto.com/data/1036876

本文转自zhf651555765 51CTO博客，原文链接：http://blog.51cto.com/smallwoniu/1338618，如需转载请自行联系原作者

微信关注我们

原文链接：https://yq.aliyun.com/articles/477743

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

【移动开发】Android中三种超实用的滑屏方式汇总（ViewPager、ViewFlipper、ViewFlow）

现如今主流的Android应用中，都少不了左右滑动滚屏这项功能，（貌似现在好多人使用智能机都习惯性的有事没事的左右滑屏，也不知道在干什么。。。嘿嘿），由于前段时间项目的需要，所以也对其研究了一下，总的来说滑屏实现有三种方式：（至于其他的实现方式目前后还没碰到。。。） 1.ViewPager2.ViewFlipper 3.ViewFlow 一.ViewPager 官方文档介绍：http://developer.android.com/reference/android/support/v4/view/ViewPager.html 根据继承关系我们可以看出，ViewPager不在android sdk 自带jar包中，来源google 的补充组件android-support-v4.jar中，所以我们在3.0以前的版本中使用就需要导入该jar包了。 1.1 介绍：该类是一个布局管理器,它允许用户通过滑动左、右页的数据。你必须要一个实现了PagerAdapter接口从而生成的页面视图。 1.2 使用： activity_main.xml 1 2 3 4 5 6 7 8 9 10 < R...

2017-11-07

632

【移动开发】Android波纹动画效果实现

今天我实现一个wifi当中搜索时的动画效果，通常我们会使用多张图片进行Frame动画播放，这里我使用了Tween动画,仅对一张图片进行操作，实现了wifi扫描动画效果，有兴趣的可以看看！效果图：这里我们采用了自定义布局的方式 activity_main.xml 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 < RelativeLayout xmlns:android = "http://schemas.android.com/apk/res/android" xmlns:tools = "http://schemas.android.com/tools" android:layout_width = "match_parent" android:layout_height = "match_parent" > < com.zhf.android_ripple.AnimationFrameLayout android:id = "@+id/search_animation_wf_main" android:layo...

2017-11-07

631

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。