精华内容
下载资源
问答
  • android 使用热点5G

    2021-01-21 09:41:42
    sudo iw list|grep MHz 查看信道 Android平台API直接通过mWifiManager.setWifiEnabled来打开热点,即调用WifiManager的方法: Z:\KK\frameworks\base\wifi\java\android\net\wifi\WifiManager.java 到服务器端进程...

    busybox ifconfig -a 查看网口

    sudo iw list|grep MHz 查看信道
    Android平台API直接通过mWifiManager.setWifiEnabled来打开热点,即调用WifiManager的方法:
    Z:\KK\frameworks\base\wifi\java\android\net\wifi\WifiManager.java
    这里写图片描述

    到服务器端进程:
    Z:\KK\frameworks\base\services\java\com\android\server\wifi\WifiService.java
    这里写图片描述
    从而调用到Wifi状态机中的实例,接着会调到mSoftApStartingState
    Z:\KK\frameworks\base\wifi\java\android\net\wifi\WifiStateMachine.java

    这里写图片描述

    加载AP对应的驱动,通过JNI调用本地方法加载驱动:
    这里写图片描述
    加载驱动成功后状态又被迁移至mSoftApStartingState
    这里写图片描述
    SoftApStartingState 会检测上层传下的参数的有效性并调用startSoftApWithConfig 配置、打开SoftAP
    这里写图片描述
    接着调用到startAccessPoint()函数
    Z:\KK\frameworks\base\services\java\com\android\server\NetworkManagementService.java

    这里写图片描述

    在此可强制修改热点的信道,如上已将mConnector.execute直接写入了36信道。

    下载AP对应的 firmware
    wifiFirmwareReload(wlanIface, “AP”);
    设置ap的ssid 信道 加密方式 以及密码
    mConnector.execute(“softap”, “set”, wlanIface, wifiConfig.SSID,
    “broadcast”, “36”, getSecurityType(wifiConfig),
    new SensitiveArg(wifiConfig.preSharedKey));3、运行softap
    mConnector.execute(“softap”, “startap”);
    这里通过一个NativeDaemonConnector的实例mConnector 调用c++程序

    这里写图片描述

    最后调用到了 “./system/netd/CommandListener.cpp” 中的CommandListener::SoftapCmd::runCommand
    这里写图片描述

    调用”set“ 命令, 调用到 rc = sSoftapCtrl->setSoftap(argc, argv);来配置网络
    这里写图片描述

    asprintf(&wbuf, “interface=%s\ndriver=nl80211\nctrl_interface=”
    “/data/misc/wifi/hostapd\nssid=%s\nchannel=%d\nieee80211n=1\n”
    “hw_mode=a\nignore_broadcast_ssid=%d\n”,
    argv[2], argv[3], channel, hidden);
    则是热点打开生成的配置文件内容,会接收到上层传来的信道和接口进行配置,此处我们若要改成5G热点,需如上修改协议hw_mode=a,channel也可以直接用信道值替换,比如153,至此热点配置修改已完成。

    展开全文
  • 1.首先建立wifi热点服务器 wifi客户端连接 2.开启一个子线程循环监听某个端口,进行数据流输入输出 /* 服务器 接收数据 */ class Receiver extends Thread { public String receiverContent; public boolean ...

    1.首先建立wifi热点服务器  wifi客户端连接

    2.开启一个子线程循环监听某个端口,进行数据流输入输出

     

    /* 服务器 接收数据 */
    class Receiver extends Thread {
    public String receiverContent;
    public boolean flag = true;
    public ServerSocket serverSocket = null;

    public void run() {
    try {
    // 创建ServerSocket
    serverSocket = new ServerSocket(3358);
    while (flag) {
    // 接受客户端请求
    Socket client = serverSocket.accept();
    System.out.println("accept");
    try {
    // 接收客户端消息
    BufferedReader in = new BufferedReader(
    new InputStreamReader(client.getInputStream()));
    receiverContent = in.readLine();
    System.out.println("read:" + receiverContent);
    handler.sendEmptyMessage(0);
    // 向客戶端发送消息
    PrintWriter out = new PrintWriter(
    new BufferedWriter(new OutputStreamWriter(
    client.getOutputStream())), true);
    out.println("server message");
    // 关闭流
    out.close();
    in.close();
    } catch (Exception e) {
    System.out.println(e.getMessage());
    e.printStackTrace();
    } finally {
    // 关闭
    client.close();
    System.out.println("close");
    }
    }
    } catch (Exception e) {
    System.out.println(e.getMessage());
    }
    }

    public void close() {
    flag = false;
    if (serverSocket != null) {
    try {
    serverSocket.close();
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    }
    }
    }

    /* 客户端发送数据 */
    class Sender extends Thread {
    String serverIp;
    String message;

    Sender(String serverAddress, String message) {
    super();
    serverIp = serverAddress;
    this.message = message;
    }

    public void run() {
    Socket sock = null;
    PrintWriter out;
    try {
    // 声明sock,其中参数为服务端的IP地址与自定义端口
    sock = new Socket(serverIp, 3358);
    Log.w("WifiConnection", "I am try to writer" + sock);
    } catch (UnknownHostException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    try {
    // 向服务器端发送消息
    out = new PrintWriter(new BufferedWriter(
    new OutputStreamWriter(sock.getOutputStream())), true);
    out.println(message);

    // 接收来自服务器端的消息
    BufferedReader br = new BufferedReader(new InputStreamReader(
    sock.getInputStream()));
    String msg = br.readLine();
    Message m = handler.obtainMessage();
    m.what = 1;
    m.obj = msg;
    handler.sendMessage(m);
    // 关闭流
    out.close();
    out.flush();
    br.close();
    // 关闭Socket
    sock.close();
    } catch (Exception e) {
    LogUtil.e("发送错误:[Sender]run()" + e.getMessage());
    }

    }
    }

    转载于:https://www.cnblogs.com/lzh-Linux/p/4589946.html

    展开全文
  • 在做android的时候,我们可能会用到web service 在myeclipse上发布一个web service服务,在手机上调用这个服务操作数据库,但是在模拟器上运行成功,但是在真机上就会显示程序无响应,原因就是,内网和外网的问题。...

    在做android的时候,我们可能会用到web service 在myeclipse上发布一个web service服务,在手机上调用这个服务操作数据库,但是在模拟器上运行成功,但是在真机上就会显示程序无响应,原因就是,内网和外网的问题。可能你的服务器端是发布在了内网上,但是,你用手机的数据连接上得时外网也即是Intent,这样的话网关是不一样的,所以程序会显示无法响应。所以,这个解决办法就是,把自己的笔记本做成一个wifi热点,共享你的网络,然后手机通过搜索wifi连接网络,这样程序就能识别正常运行了。

             下面就说一下windows 7设置wifi网络热点的技术,以操作系统为win7的笔记本或装有无线网卡的台式机作为主机。
               1、 以管理员身份运行命令提示符:快捷键win+R→输入cmd→回车
                  2、 启用并设定虚拟WiFi网卡: 运行命令:netsh wlan set hostednetwork mode=allow ssid=hgmPC key=hgaoming

                        此命令有三个参数,mode:是否启用虚拟WiFi网卡,改为disallow则为禁用。

                                                         ssid:无线网名称,最好用英文(以wuminPC为例)。

                                                         key:无线网密码,八个以上字符(以wuminWiFi为例)。

                        以上三个参数可以单独使用,例如只使用mode=disallow可以直接禁用虚拟Wifi网卡。

                开启成功后,网络连接中会多出一个网卡为“Microsoft Virtual WiFi Miniport Adapter”的无线连接2,为方便起见,将其重

    名为虚拟WiFi。若没有,只需更新无线网卡驱动就OK了。

    3、设置Internet连接共享:

    在“网络连接”窗口中,右键单击已连接到Internet的网络连接,选择“属性”→“共享”,勾上“允许其他······连接(N)”并选择“

    虚拟WiFi”,你可以看到宽带连接下边是“共享的”!

    4、开启无线网络:

    继续在命令提示符中运行:netsh wlan start hostednetwork


    至此,虚拟WiFi的红叉叉消失,WiFi基站已组建好,主机设置完毕。笔记本、带WiFi模块的手机等子机搜索到无线网络hgmPC,

    输入密码haogaoming,就能共享上网啦!

    然后调用web service 进行就可以操作数据库了,这时网络就没有问题了。还等什么。。快点实践吧。

    展开全文
  • Android Wifi热点 数据传输Socket 通信

    千次阅读 2018-04-20 15:24:50
    首先,描述下功能,两个手机,其中一个手机开热点,另外一个手机连接热点,2个手机间数据通信(不需要流量)。...开热点的作为服务器端 初始化数据: public static final int DEVICE_CONNECTING = 1;//有...

    首先,描述下功能,两个手机,其中一个手机开热点,另外一个手机连接热点,2个手机间数据通信(不需要流量)。简述一下原理:开热点的手机相当于路由器,连接的手机作为客户端,获取路由器的IP建立Socket 连接,开始双方通信。

    一、服务器端:

    开热点的作为服务器端

    初始化数据:

        public static final int DEVICE_CONNECTING = 1;//有设备正在连接热点
        public static final int DEVICE_CONNECTED  = 2;//有设备连上热点
        public static final int SEND_MSG_SUCCSEE  = 3;//发送消息成功
        public static final int SEND_MSG_ERROR    = 4;//发送消息失败
        public static final int GET_MSG           = 6;//获取新消息
        private TextView      text_state;
        private WifiManager   wifiManager;
        /**
         * 连接线程
         */
        private ConnectThread connectThread;
    
    
        /**
         * 监听线程
         */
        private ListenerThread listenerThread;
        /**
         * 热点名称
         */
        private static final String WIFI_HOTSPOT_SSID = "TEST";
        /**
         * 端口号
         */
        private static final int    PORT              = 54321;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            findViewById(R.id.create_wifi).setOnClickListener(this);
            findViewById(R.id.close_wifi).setOnClickListener(this);
            findViewById(R.id.send).setOnClickListener(this);
            text_state = (TextView) findViewById(R.id.receive);
    
    
            wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
            /**
             * 先开启监听线程,在开启连接
             */
            listenerThread = new ListenerThread(PORT, handler);
            listenerThread.start();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //        开启连接线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress());
                        //本地路由开启通信
                        String ip = getWifiApIpAddress();
                        if (ip != null) {
                        } else {
                            ip = "192.168.43.1";
                        }
                        Socket socket = new Socket(ip, PORT);
                        connectThread = new ConnectThread(MainActivity.this, socket, handler);
                        connectThread.start();
    
                    } catch (IOException e) {
                        e.printStackTrace();
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                text_state.setText("创建通信失败");
                            }
                        });
    
                    }
                }
            }).start();
    
    
        }

    创建wifi 热点,之后开启Socket 监听线程

     /**
         * 创建Wifi热点
         */
        private void createWifiHotspot() {
            if (wifiManager.isWifiEnabled()) {
                //如果wifi处于打开状态,则关闭wifi,
                wifiManager.setWifiEnabled(false);
            }
            final WifiConfiguration config = new WifiConfiguration();
            config.SSID = WIFI_HOTSPOT_SSID;
            config.preSharedKey = "123456789";
            config.hiddenSSID = false;
            config.allowedAuthAlgorithms
                    .set(WifiConfiguration.AuthAlgorithm.OPEN);//开放系统认证
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;
            //通过反射调用设置热点
    
            //192.168.43.59
            //        Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress() +
            //                "\n");
            try {
                Method method = wifiManager.getClass().getMethod(
                        "setWifiApEnabled", WifiConfiguration.class, Boolean.TYPE);
                boolean enable = (Boolean) method.invoke(wifiManager, config, true);
                if (enable) {
                    text_state.setText("热点已开启 SSID:" + WIFI_HOTSPOT_SSID + " password:123456789");
    
    
                    //        开启连接线程
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                Log.i("ip", "getWifiApIpAddress()" + getWifiApIpAddress()
                                );
                                String ip = getWifiApIpAddress();
                                if (ip != null) {
                                } else {
                                    //一般Android手机默认路由是
                                    ip = "192.168.43.1";
                                }
                                //本地路由开启通信
                                Socket socket = new Socket(ip, PORT);
                                connectThread = new ConnectThread(MainActivity.this, socket, handler);
                                connectThread.start();
    
    
                            } catch (IOException e) {
                                e.printStackTrace();
                                runOnUiThread(new Runnable() {
                                    @Override
                                    public void run() {
                                        text_state.setText("创建通信失败");
                                    }
                                });
    
                            }
                        }
                    }).start();
                    Thread.sleep(1000);
    
                    //                listenerThread = new ListenerThread(PORT, handler);
                    //                listenerThread.start();
                } else {
                    text_state.setText("创建热点失败");
                }
            } catch (Exception e) {
                e.printStackTrace();
                text_state.setText("创建热点失败");
            }
        }
    

    服务器端获取本地路由:

       public String getWifiApIpAddress() {
            try {
                for (Enumeration<NetworkInterface> en = NetworkInterface
                        .getNetworkInterfaces(); en.hasMoreElements(); ) {
                    NetworkInterface intf = en.nextElement();
                    if (intf.getName().contains("wlan")) {
                        for (Enumeration<InetAddress> enumIpAddr = intf
                                .getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
                            InetAddress inetAddress = enumIpAddr.nextElement();
                            if (!inetAddress.isLoopbackAddress()
                                    && (inetAddress.getAddress().length == 4)) {
                                Log.d("Main", inetAddress.getHostAddress());
                                return inetAddress.getHostAddress();
                            }
                        }
                    }
                }
            } catch (SocketException ex) {
                Log.e("Main", ex.toString());
            }
            return null;
        }
    

    关闭热点

     /**
         * 关闭WiFi热点
         */
        public void closeWifiHotspot() {
            try {
                Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");
                method.setAccessible(true);
                WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);
                Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
                method2.invoke(wifiManager, config, false);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            text_state.setText("热点已关闭");
        }

    ListenerThread 监听线程

    import android.os.Handler;
    import android.os.Message;
    import android.util.Log;
    
    import com.example.syhuang.wifiserver.MainActivity;
    
    import java.io.IOException;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * 监听线程
     * Created by syh on 2018/4/3
     */
    public class ListenerThread extends Thread {
    
        private ServerSocket serverSocket = null;
        private Handler handler;
        private int     port;
        private Socket  socket;
    
        public ListenerThread(int port, Handler handler) {
            setName("ListenerThread");
            this.port = port;
            this.handler = handler;
            try {
                serverSocket = new ServerSocket(port);//监听本机的12345端口
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    
        @Override
        public void run() {
            while (true) {
                try {
                    Log.i("ListennerThread", "阻塞");
                    //阻塞,等待设备连接
                    if (serverSocket != null)
                        socket = serverSocket.accept();
                    Message message = Message.obtain();
                    message.what = MainActivity.DEVICE_CONNECTING;
                    handler.sendMessage(message);
                } catch (IOException e) {
                    Log.i("ListennerThread", "error:" + e.getMessage());
                    e.printStackTrace();
                }
            }
        }
    
        public Socket getSocket() {
            return socket;
        }
    }

    ConnectThread 连接线程

    package com.example.syhuang.wifiserver.thread;
    
    import android.content.Context;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.util.Log;
    
    import com.example.syhuang.wifiserver.MainActivity;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    import java.text.DecimalFormat;
    
    /**
     * 连接线程
     * Created by syhuang on 2018/4/3
     */
    public class ConnectThread extends Thread {
    
        private final Socket       socket;
        private       Handler      handler;
        private       InputStream  inputStream;
        private       OutputStream outputStream;
        Context context;
    
        public ConnectThread(Context context, Socket socket, Handler handler) {
            setName("ConnectThread");
            Log.i("ConnectThread", "ConnectThread");
            this.socket = socket;
            this.handler = handler;
            this.context = context;
        }
    
        @Override
        public void run() {
    /*        if(activeConnect){
    //            socket.c
            }*/
            if (socket == null) {
                return;
            }
            handler.sendEmptyMessage(MainActivity.DEVICE_CONNECTED);
            try {
                //获取数据流
                inputStream = socket.getInputStream();
                outputStream = socket.getOutputStream();
    
                byte[] buffer = new byte[1024];
                int bytes;
                while (true) {
    
                    //读取数据
                    bytes = inputStream.read(buffer);
                    if (bytes > 0) {
                        final byte[] data = new byte[bytes];
                        System.arraycopy(buffer, 0, data, 0, bytes);
    
                        Message message = Message.obtain();
                        message.what = MainActivity.GET_MSG;
                        Bundle bundle = new Bundle();
                        bundle.putString("MSG", new String(data));
                        message.setData(bundle);
                        handler.sendMessage(message);
                    }
                    //                DataInputStream dis = null;
                    //                FileOutputStream fos = null;
                    //                try {
                    //                    dis = new DataInputStream(inputStream);
                    //
                    //                    // 文件名和长度
                    //                    String fileName = dis.readUTF();
                    //                    if (!fileName.equals("")) {
                    //                        long fileLength = dis.readLong();
                    //                        Log.i("ConnectThread", "======== 文件接收 [File Name:" + fileName + "] " +
                    //                                "[Size:" + getFormatFileSize(fileLength) + "] ========");
                    //                        File directory = new File(Environment.getExternalStorageDirectory() + "/");
                    //                        if (!directory.exists()) {
                    //                            directory.mkdir();
                    //                        } else {
                    //                        }
                    //                        File file = new File(directory.getAbsolutePath() + File.separatorChar + fileName);
                    //                        fos = new FileOutputStream(file);
                    //
                    //                        // 开始接收文件
                    //                        byte[] bytesA = new byte[1024];
                    //                        int length = 0;
                    //                        int progress = 0;
                    //                        while ((length = dis.read(bytesA, 0, bytesA.length)) != -1) {
                    //                            Log.i("ConnectThread", length + "...");
                    //                            fos.write(bytesA, 0, length);
                    //                            fos.flush();
                    //                            progress += length;
                    //                            Log.i("ConnectThread", "| " + (100 * progress / file.length()) + "% |");
                    //                        }
                    //                        Log.i("ConnectThread", "文件传输完成");
                    //
                    //                        Message message = Message.obtain();
                    //                        message.what = MainActivity.GET_MSG;
                    //                        Bundle bundle = new Bundle();
                    //                        bundle.putString("MSG", new String("接收到文件:" + file.getAbsolutePath()));
                    //                        message.setData(bundle);
                    //                        handler.sendMessage(message);
                    //                    } else {
                    //                        //读取数据
                    //                        bytes = inputStream.read(buffer);
                    //                        if (bytes > 0) {
                    //                            final byte[] data = new byte[bytes];
                    //                            System.arraycopy(buffer, 0, data, 0, bytes);
                    //
                    //
                    //                            Message message = Message.obtain();
                    //                            message.what = MainActivity.GET_MSG;
                    //                            Bundle bundle = new Bundle();
                    //                            bundle.putString("MSG", new String(data));
                    //                            message.setData(bundle);
                    //                            handler.sendMessage(message);
                    //
                    //                            Log.i("ConnectThread", "读取到数据:" + new String(data));
                    //                        }
                    //                    }
    
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 格式化文件大小
         *
         * @param length
         * @return
         */
        private String getFormatFileSize(long length) {
            DecimalFormat df = new DecimalFormat("#0.0");
            double size = ((double) length) / (1 << 30);
            if (size >= 1) {
                return df.format(size) + "GB";
            }
            size = ((double) length) / (1 << 20);
            if (size >= 1) {
                return df.format(size) + "MB";
            }
            size = ((double) length) / (1 << 10);
            if (size >= 1) {
                return df.format(size) + "KB";
            }
            return length + "B";
        }
    
        public static boolean copyFile(InputStream inputStream, OutputStream out) {
            byte buf[] = new byte[1024];
            int len;
            try {
                while ((len = inputStream.read(buf)) != -1) {
                    out.write(buf, 0, len);
    
                }
                out.close();
                //            inputStream.close();
            } catch (IOException e) {
    
                return false;
            }
            return true;
        }
    
        /**
         * 发送数据
         */
        public void sendData(String msg) {
            Log.i("ConnectThread", "发送数据:" + (outputStream == null));
            if (outputStream != null) {
                try {
                    outputStream.write(msg.getBytes());
                    Log.i("ConnectThread", "发送消息:" + msg);
                    Message message = Message.obtain();
                    message.what = MainActivity.SEND_MSG_SUCCSEE;
                    Bundle bundle = new Bundle();
                    bundle.putString("MSG", new String(msg));
                    message.setData(bundle);
                    handler.sendMessage(message);
                } catch (IOException e) {
                    e.printStackTrace();
                    Message message = Message.obtain();
                    message.what = MainActivity.SEND_MSG_ERROR;
                    Bundle bundle = new Bundle();
                    bundle.putString("MSG", new String(msg));
                    message.setData(bundle);
                    handler.sendMessage(message);
                }
            }
        }
    
    }
    

    二、客户端

    客户端连接到热点,代码差不多,初始化数据部分顺序不一样,先开启连接线程,在开启监听线程,获取路由器IP 地址有差别。其他基本一样。

    wifi获取 已连接网络路由 路由ip地址

        /**
         * wifi获取 已连接网络路由  路由ip地址
         * @param context
         * @return
         */
        private static String getWifiRouteIPAddress(Context context) {
            WifiManager wifi_service = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            DhcpInfo dhcpInfo = wifi_service.getDhcpInfo();
            //        WifiInfo wifiinfo = wifi_service.getConnectionInfo();
            //        System.out.println("Wifi info----->" + wifiinfo.getIpAddress());
            //        System.out.println("DHCP info gateway----->" + Formatter.formatIpAddress(dhcpInfo.gateway));
            //        System.out.println("DHCP info netmask----->" + Formatter.formatIpAddress(dhcpInfo.netmask));
            //DhcpInfo中的ipAddress是一个int型的变量,通过Formatter将其转化为字符串IP地址
            String routeIp = Formatter.formatIpAddress(dhcpInfo.gateway);
            Log.i("route ip", "wifi route ip:" + routeIp);
    
            return routeIp;
        }

    初始化

     public static final int DEVICE_CONNECTING = 1;//有设备正在连接热点
        public static final int DEVICE_CONNECTED  = 2;//有设备连上热点
        public static final int SEND_MSG_SUCCSEE  = 3;//发送消息成功
        public static final int SEND_MSG_ERROR    = 4;//发送消息失败
        public static final int GET_MSG           = 6;//获取新消息
    
        private TextView      text_state;
        /**
         * 连接线程
         */
        private ConnectThread connectThread;
    
    
        /**
         * 监听线程
         */
        private ListenerThread listenerThread;
    
        /**
         * 热点名称
         */
        private static final String WIFI_HOTSPOT_SSID = "TEST";
        /**
         * 端口号
         */
        private static final int    PORT              = 54321;
        private WifiManager wifiManager;
    
        private TextView status_init;
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            findViewById(R.id.send).setOnClickListener(this);
            findViewById(R.id.connect).setOnClickListener(this);
            findViewById(R.id.fileButton).setOnClickListener(this);
            wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    
            //检查Wifi状态
            if (!wifiManager.isWifiEnabled())
                wifiManager.setWifiEnabled(true);
            text_state = (TextView) findViewById(R.id.status_info);
            status_init = (TextView) findViewById(R.id.status_init);
    
    
            status_init.setText("已连接到:" + wifiManager.getConnectionInfo().getSSID() +
                    "\nIP:" + getIp()
                    + "\n路由:" + getWifiRouteIPAddress(MainActivity.this));
    
            //        initBroadcastReceiver();
            //        开启连接线程
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Socket socket = new Socket(getWifiRouteIPAddress(MainActivity.this), PORT);
                        connectThread = new ConnectThread(socket, handler);
                        connectThread.start();
                    } catch (IOException e) {
                        e.printStackTrace();
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                text_state.setText("通信连接失败");
                            }
                        });
    
                    }
                }
            }).start();
    
    
            listenerThread = new ListenerThread(PORT, handler);
            listenerThread.start();
        }
    

    服务器和客户端Handler处理一样

      private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case DEVICE_CONNECTING:
                        connectThread = new ConnectThread(listenerThread.getSocket(), handler);
                        connectThread.start();
                        break;
                    case DEVICE_CONNECTED:
                        text_state.setText("设备连接成功");
                        break;
                    case SEND_MSG_SUCCSEE:
                        text_state.setText("发送消息成功:" + msg.getData().getString("MSG"));
                        break;
                    case SEND_MSG_ERROR:
                        text_state.setText("发送消息失败:" + msg.getData().getString("MSG"));
                        break;
                    case GET_MSG:
                        text_state.setText("收到消息:" + msg.getData().getString("MSG"));
                        break;
                }
            }
        };
    
    

    源码传送门

    参考文章:

    Android 连接Wifi和创建Wifi热点 demo - CSDN博客
    Android WiFi开发 (一)扫描、连接、信息 - CSDN博客
    Android/安卓开发之WIFI的基本应用 - CSDN博客
    Android设备之间通过Wifi通信 - sowhat4999 - 博客园
    Android WiFi开发教程(三)——WiFi热点数据传输 - CSDN博客
    【Android】Android手机通过wifi进行数据传输 - CSDN博客
    android wifi 点对点传输 - 简书
    android WIFI Socket 文件传输 - Android移动开发技术文章_手机开发 - 红黑联盟
    Android 实现无网络传输文件用户5207283611新浪博客
    wifi direct—深入理解Wi-Fi P2P - CSDN博客
    (高效开发)Android手机间使用socket进行文件互传实例 - CSDN博客
    Android仿茄子快传-实现面对面快传功能 - CSDN博客
    安卓手机wifi面对面快传的实现 - CSDN博客

    展开全文
  • android增加5G热点

    千次阅读 2017-03-28 14:21:31
    busybox ifconfig -a 查看网口...Android平台API直接通过mWifiManager.setWifiEnabled来打开热点,即调用WifiManager的方法: Z:\KK\frameworks\base\wifi\java\android\net\wifi\WifiManager.java 到服务器端进程:
  • 两台手机,一台做WIFI热点,一台接入【或者用蓝牙连接吧】,反正就两台手机连接到同一个网络。 其中一台手机作为服务器,另外一台手机作为客户端接入,用socket连接时需要知道作为服务器的手机的IP地址还有端口号...
  • 应用效果图: 客户端 ...
  • 拥有了linuxonandroid,就有了两个想法,利用手机可以随时随地的谢谢程序,代替了笔记本。 把手机搞成一个小server,跑个服务器什么的。在人多的地方,可以放出一个wifi热点,推销产品使用。具有流动性强的特点。 ...
  • 在学习android网络编程时,使用模拟器访问本地服务器(Tomcat)时,使用本机IP地址即可访问,当使用真机时,发现会出现java.net.SocketTimeoutException: failed to connect to /IP地址(port 80) after 3000ms的错误...
  • Android实现Wifi数据传输两部手机连接wifi后,通过socket...A手机创建WIFI热点作为服务器,B手机连接A手机WIFI热点,作为客户端.rar,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • 最近接到一个项目是关于android与tv交互的一个项目,一共分为两个端,一个是控制端(手机端),一个是播放端,现在需求是这样的,手机端从服务器下载文件,播放端开启热点,手机端链接热点,对播放端进行文件上传,...
  • Android WIFI通信scoket通信聊天室WiFi互传文件WiFi热点开启,通过建立WiFi热点,启动scoket服务器服务器进行互相传输文件聊天等,服务器、客户端再同一APP内,可装在2个手机里分别启动服务器和客户端。
  • 这个是前几年之前接触到的一个项目的需求,需要是android手机建立一个无线热点,其他设备连接热点后,访问网站,都跳转到android手机上热点提供的网站,所以就需要android手机端实现一个简易的web服务器服务器的...
  • 域名是由圆点分开一串单词或缩写组成的,每一个域名都对应一个惟一的IP地址,在Internet上域名与IP地址之间是一一对应的,DNS就是进行域名解析的服务器。DNS命名用于Internet等TCP/IP网络中,通过用户友好的名称查找...
  • android手机如何访问电脑tomcat服务器

    千次阅读 2016-11-05 21:06:23
    今天要用手机访问PC本地tomcat的服务器,手机和电脑都是wifi上网,且连接的是同一个路由器(联通路由器的wifi),刚开始用手机访问电脑ip的tomcat服务器不成功,最后在pc上设置一个wifi热点,手机使用此热点上网(刚...
  • 第一步,随便用个开wifi软件开启笔记本局域网wifi热点,然后然后需要注意三点1、android的AndroidManifest需要开启几个权限,见如下加粗代码&lt;?xml version="1.0" encoding="utf-8"?&...
  • 手机浏览器输入:http://localhost:8080/无法访问本地开启的Tomcat服务器。 解决方案:  保证手机和电脑访问的是同...如果没有无线网,可以通过设置让自己笔记本电脑当WIFI热点,让手机访问这个WIFE,也能达到效...
  • 1.先说访问Tomcat问题,一般...直接手机开热点,电脑连接热点就好了,这样就是在同一个局域网里了如果还是不放心可以在手机上下载一个超级终端之类的命令行软件,然后执行ifconfig,查看一下自己的IP,电脑端的话是i
  • 其实win7本身就自带无线热点的功能,按下面的方法设置。 开启windows 7的隐藏功能:虚拟WiFi和SoftAP(即虚拟无线AP),就可以让电脑变成无线路由器,实现共享上网,节省网费和路由器购买费。 以操作系统为win7的...
  • 不论使用什么软件编写的Android程序连接本地服务器都需要使手机和电脑在同一个网关下,这可用win10系统自带的移动热点给测试手机开热点,或者用手机给电脑开热点。查找电脑ip地址的方法如下:win+R输入cmd,打开命令...
  • 在开发android项目时用真机调式时,不免要连接服务器,下面介绍在真机上访问本机服务器的案例: ###1、要保证在同一个局域网中### 该局域网可以是自己手机开的热点,也可以是手机和电脑连同一个WiFi。 ###2、关闭...
  • 应用如何在手机上访问本地电脑上的tomcat服务器,设置”localhost”或者”127.0.0.1”是不行的,在模拟器...本地电脑搭建的服务器与手机共同连接到同一个局域网网络下,可以使用电脑开热点,让真机连上热点就在同一局
  • 服务器学习 https://blog.csdn.net/a_running_wolf/article/details/52579178 不用电脑开热点,手机和电脑在同一个局域网就行。 出现的问题 response.setContentType(“text/html;charset=utf-8”); // 设置响应...
  • 首先保证你的电脑和你的手机在同一个热点下,可以自己手机开热点,电脑连接 解决办法: 在你手机的 设置 界面 找到 应用程序管理 ,找到你要调试的 expo 找到权限管理 对显示浮动窗口勾选 ,清楚下全部数...
  • 把localhost或者127.0.0.1改成你本机的IP,前提是你个自己的电脑在同一个局域网上,让你的电脑的网变成WIFI热点,然后再用手机连上这个网。用wifi分享器可以做到的模拟器上(转):android模拟器(simulator)把它...
  • 通过服务器返回的数据显示,一共是293页的数据,不可能1页就加载完成,先加载第一页的数据。 //获取文章列表 article/list/0/json @GET("article/list/{id}/json") public Call<AListBean> ...
  • 视频:包括热点、搞笑、娱乐、精品视频 关注:包括朋友圈、日夜模式切换(无需重启界面)功能 项目亮点: mvp模式:解耦model和view层,契约类管理mvp,一目了然,实现纵向解耦,基类完美封装,避免频繁new对象 ...
  • 前期准备:我的是Linux Mint操作系统(总之折腾的过程中怀疑过是不是系统的问题),首先是要创建wifi热点android手机使用,这个时候笔记本作为通信的服务器端,android手机作为客户端,通过socket进行通信。...
  • 权限申请,代码开启热点,开启服务器 package com.example.administrator.wifitrainingclothes.service; import android.app.Service; import android.content.Intent; import android.os.Binder; import ...
  • Android 开发技巧

    热门讨论 2012-03-26 10:24:42
    9.37、通过ANDROID 客户端上传数据到服务器 251 9.38、文件下载类 255 9.39、下载文件的进度条提示 263 9.40、通过HTTPCLIENT从指定SERVER获取数据 265 9.41、通过FTP传输文件,关闭UI获得返回码 266 9.42、激活...

空空如也

空空如也

1 2 3 4 5
收藏数 92
精华内容 36
关键字:

android服务器热点