android 服务器 热点_android设备做服务器更新另一台android的apk - CSDN
  • 热点进行开关和设置操作,获取热点的状态已经连接列表,热点和WiFi通信

    在我的上一篇博客写了WiFi开发,这一篇自然就是热点开发,然后就是二者之间的通信了。如还不懂WiFi开发的参考上一篇博客http://blog.csdn.net/lhp15575865420/article/details/78357434

    对于热点。我们需要能够打开和关闭,自己设置热点名和密码以及锁的类型。然后呢,还要能够获取连接此热点的设备信息。关于热点,没有找到相应的操作类,查阅资料后得知要用method反射机制来实现。反射机制不了解的自行百度。下面直接贴上相关代码及解析

    public class Mywifiap {
    
        private static final int NO_PASS=0;
        private static final int WPA_PSK=1;
        private static final int WPA2_PSK=2;
    
        private WifiManager wifiManager;
        private WifiConfiguration apconfig;
    
        public Mywifiap(Context context) {
            wifiManager= (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        }
    
        //开启热点
        public void openwifiap(String name,String password,int type){
            if(wifiManager.isWifiEnabled())
                wifiManager.setWifiEnabled(false);//如果WiFi是开启的就关闭WiFi。
            apconfig=new WifiConfiguration();
            apconfig.SSID=name;//设置WiFi名字
    
            //热点相关设置
            switch (type){
                case NO_PASS:
                    apconfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                    apconfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                    apconfig.wepKeys[0]="";
                    apconfig.wepTxKeyIndex=0;
                    break;
                case WPA_PSK:
                    apconfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                    apconfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
                    apconfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                    apconfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                    apconfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
                    apconfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
                    apconfig.preSharedKey=password;
                    break;
                case WPA2_PSK:
                    //由于wpa2是不能直接访问的,但是KeyMgmt中却有。所以我们这样写
                    for(int i=0;i<WifiConfiguration.KeyMgmt.strings.length;i++){
                        if("WPA2_PSK".equals(WifiConfiguration.KeyMgmt.strings[i])) {
                            apconfig.allowedKeyManagement.set(i);//直接给它赋索引的值
                            Log.e("wpa2索引", String.valueOf(i));//不同手机索引不同
                        }
                    }
                    apconfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
                    apconfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
                    apconfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                    apconfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
                    apconfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
                    apconfig.preSharedKey=password;
                    break;
            }
    
            try {
    
                Method method=wifiManager.getClass().getMethod("setWifiApEnabled",WifiConfiguration.class,boolean.class);
                method.invoke(wifiManager,apconfig,true);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    
        //关闭热点
        public void closewifiap(){
            try {
    //            Method method1=wifiManager.getClass().getMethod("getWifiApConfiguration");
    //            method1.setAccessible(true);
    //            WifiConfiguration nowconfig= (WifiConfiguration) method1.invoke(wifiManager);//获取当前热点
                Method method=wifiManager.getClass().getMethod("setWifiApEnabled",WifiConfiguration.class,boolean.class);
                method.invoke(wifiManager,apconfig,false);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        }
    
        //获取连接列表
        public StringBuffer getconnectlist(){
            /*
            连接设备的信息都存在一个文件里面,读这个文件获取信息
            读取文件后每为这样的格式,每连接一个设备增加一行,没有连接时只有一行
            IP address       HW type     Flags       HW address            Mask     Device
            192.168.43.115   0x1         0x2         c4:0b:cb:8a:4c:f1     *        ap0
            192.168.43.115   0x1         0x2         c4:0b:cb:8a:4c:f1     *        ap0
             */
            StringBuffer sb=new StringBuffer();
            try {
                BufferedReader br=new BufferedReader(new FileReader("/proc/net/arp"));
                String line;
                while((line=br.readLine())!=null){
                    Log.e("连接列表",line);
                    sb.append(line+"\n");
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return sb;
        }
    
    }
    关于监听热点状态,它是有一个广播的,通过这个广播就可以监听到了热点开关的实时状态
    public class ApReceiver extends BroadcastReceiver{
    
        @Override
        public void onReceive(Context context, Intent intent) {
            String action=intent.getAction();
            if("android.net.wifi.WIFI_AP_STATE_CHANGED".equals(action)){
                //"android.net.wifi.WIFI_AP_STATE_CHANGED"这个是热点状态改变的广播
                int state=intent.getIntExtra("wifi_state",0);
                Log.e("热点状态", String.valueOf(state));
                /* state:
                12:正在开启热点
                13:已开启热点
                10:正在关闭热点
                11:已关闭热点
                 */
            }
    
        }
    }

    然后来说说WiFi、热点通信,其实WiFi连接热点后,他们就在一个局域网中了,也就是说,他们可以通过socket来通信。然后就要在原来的基础上加上联网权限。
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>
        <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>
        <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"></uses-permission>
        <uses-permission android:name="android.permission.INTERNET"></uses-permission>
    既然用socket,端口可以自己设但是客户端必须要知道服务端的IP地址才能通信,所以,在之前WiFi开发的类上加上获取服务端IP的方法。
    //获取连接热点的IP地址
        public static String getserverip(Context context){
            WifiManager manager= (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
            DhcpInfo dhcpInfo=manager.getDhcpInfo();
            int ip=dhcpInfo.serverAddress;
            //整形转化为IP地址
            String sip=(ip&0xff)+"."+((ip>>8)&0xff)+"."+((ip>>16)&0xff)+"."+((ip>>24)&0xff);
            Log.e("服务器IP",sip);
            return sip;
        }
    客户(WiFi)端的socket代码
    public class WifiSocket extends AppCompatActivity{
        private EditText msg;
        private Button putmsg;
        private OutputStream out;
    
        Handler handler=new Handler(){
    
            @Override
            public void handleMessage(Message msg) {
                if(msg.what==1){
                    Toast.makeText(WifiSocket.this, (String) msg.obj,Toast.LENGTH_SHORT).show();
                }
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.wifisocket);
    
            msg= (EditText) findViewById(R.id.msg);
            putmsg= (Button) findViewById(R.id.putmsg);
    
            putmsg.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    try {
                        //发送消息
                        out.write(msg.getText().toString().getBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            thread();
    
        }
    
        public void thread(){
            final String ip=Mywifi.getserverip(WifiSocket.this);
            final int port=1234;
            new Thread(){
                @Override
                public void run() {
                    try {
                        Socket socket=new Socket(ip,port);
                        Log.e("wifisocket","建立连接");
                        InputStream in=socket.getInputStream();
                        out=socket.getOutputStream();
    
                        //接收消息
                        while (true){
                            byte[] buffer=new byte[1024];
                            int len=0;
                            if((len=in.read(buffer))!=-1){
                                byte[] data=new byte[len];
                                for(int i=0;i<data.length;i++)
                                    data[i]=buffer[i];
                                String msg=new String(data);
                                Log.e("收到消息",msg);
    
                                Message message=new Message();
                                message.what=1;
                                message.obj=msg;
                                handler.sendMessage(message);
                            }
                        }
    
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
    
                }
            }.start();
        }
    }
    服务(热点)端的socket代码
    public class Server extends Thread{
        public ServerSocket serverSocket;
        public Socket socket;
        public static final int PORT=1234;
    
        public Context context;
        public Handler handler;
    
        public Server(Context context,Handler handler){
            this.context=context;
            this.handler=handler;
        }
    
        @Override
        public void run() {
            try {
                serverSocket=new ServerSocket(PORT);
                Log.e("wifi服务器","已开启");
                socket=serverSocket.accept();
                Log.e("wifi服务器","设备已连接");
    
                InputStream in=socket.getInputStream();
                OutputStream out=socket.getOutputStream();
    
                //接收到消息后,马上发送一条消息
                while(true){
                    byte[] buffer=new byte[1024];
                    int len=0;
                    if((len=in.read(buffer))!=-1){
                        byte[] data=new byte[len];
                        for(int i=0;i<data.length;i++)
                            data[i]=buffer[i];
                        String msg=new String(data);
                        Log.e("收到消息",msg);
                        //通过handle来弹出Toast。
                        Message message=new Message();
                        message.obj=msg;
                        message.what=1;
                        handler.sendMessage(message);
    
                        //发送消息
                        out.write("对方已接收消息".getBytes());
                    }
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    最后,给出一个项目下载地址:http://download.csdn.net/download/lhp15575865420/10043720

    注意:这个项目在6.0以下设备有限,在6.0及以上设备,会抛出一个没有授权读写系统设置的异常,因为6.0是设备,隐私权限必须动态获取,开关热点等属于隐私权限必须在代码里动态获取。如果是6.0及以上设备,那就自己加几行动态获取权限的代码

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

    首先,描述下功能,两个手机,其中一个手机开热点,另外一个手机连接热点,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 15:33:29
    busybox ifconfig -a 查看网口...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,至此热点配置修改已完成。

    展开全文
  • 这个是前几年之前接触到的一个项目的需求,需要是android手机建立一个无线热点,其他设备连接热点后,访问网站,都跳转到android手机上热点提供的网站,所以就需要android手机端实现一个简易的web服务器服务器的...

    在android上如何编写一个小型web服务器?

    这个是前几年之前接触到的一个项目的需求,需要是android手机建立一个无线热点,其他设备连接热点后,访问网站,都跳转到android手机上热点提供的网站,所以就需要android手机端实现一个简易的web服务器,服务器的资源文件都存储在sd卡,并且可以更新。

    废话不多说,这边把项目早期做的可行性研究的demo整理了下,开源出来。

    这个小型web服务器很大一部分参考AndroidWebServ工程(https://github.com/joinAero/AndroidWebServ),在此多谢。

    刚刚百度了下,已经有很多大牛也实现了类似的功能,用的方法也基本一致。这边在大概介绍下用到的具体技术

    1:创建一个ServerSocket

    2:使用HttpService创建一个Http服务,并为这个http创建需要的HTTP请求执行器(用来响应客户端发过来的get,download,upload等请求)

    3:接收通过ServerSocket过来的Socket请求,并将Socket映射到HttpService上,这样HttpService就会返回对应的数据到客户端,客户端就能浏览网页了

    核心代码在org.join.ws.serv.WebServer上,这边摘取部分片段

     

    // 创建服务器套接字
                serverSocket = new ServerSocket(port);
                // 设置端口重用
                serverSocket.setReuseAddress(true);
                // 创建HTTP协议处理器
                BasicHttpProcessor httpproc = new BasicHttpProcessor();
                // 增加HTTP协议拦截器
                httpproc.addInterceptor(new ResponseDate());
                httpproc.addInterceptor(new ResponseServer());
                httpproc.addInterceptor(new ResponseContent());
                httpproc.addInterceptor(new ResponseConnControl());
                // 创建HTTP服务
                HttpService httpService = new HttpService(httpproc,
                        new DefaultConnectionReuseStrategy(), new DefaultHttpResponseFactory());
                // 创建HTTP参数
                HttpParams params = new BasicHttpParams();
                params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 5000)
                        .setIntParameter(CoreConnectionPNames.SOCKET_BUFFER_SIZE, 8 * 1024)
                        .setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, false)
                        .setBooleanParameter(CoreConnectionPNames.TCP_NODELAY, true)
                        .setParameter(CoreProtocolPNames.ORIGIN_SERVER, "WebServer/1.1");
                // 设置HTTP参数
                httpService.setParams(params);
                // 创建HTTP请求执行器注册表
                HttpRequestHandlerRegistry reqistry = new HttpRequestHandlerRegistry();
                // 增加HTTP请求执行器
                reqistry.register(UrlPattern.DOWNLOAD, new HttpDownHandler(webRoot));
                reqistry.register(UrlPattern.DELETE, new HttpDelHandler(webRoot));
                reqistry.register(UrlPattern.UPLOAD, new HttpUpHandler(webRoot));
                reqistry.register(UrlPattern.PROGRESS, new HttpProgressHandler());
                reqistry.register(UrlPattern.BROWSE, new HttpFBHandler(webRoot));
                // 设置HTTP请求执行器
                httpService.setHandlerResolver(reqistry);
                // 回调通知服务开始
                if (mListener != null) {
                    mListener.onStarted();
                }
                /* 循环接收各客户端 */
                isLoop = true;
                while (isLoop && !Thread.interrupted()) {
                    // 接收客户端套接字
                    Socket socket = serverSocket.accept();
                    // 绑定至服务器端HTTP连接
                    DefaultHttpServerConnection conn = new DefaultHttpServerConnection();
                    conn.bind(socket, params);
                    // 派送至WorkerThread处理请求
                    Thread t = new WorkerThread(httpService, conn, mListener);
                    t.setDaemon(true); // 设为守护线程
                    pool.execute(t); // 执行
                }


    项目中还用到 一个比较重要的库,Jangod,这个库很强大,可以用来从文件或者从代码中加载html,并支持css,有兴趣的同学可以 继续研究下去。

     

    另外还有一个问题,怎么样把客户端所有的http请求都引到我们的ServerSocket?这边就需要用到nat表了,前提是你手机root了

    1:将所有对80端口的http请求都强制转换到我们的ServerSocket,命令如下

     

    	        String cmd = "iptables -t nat -A PREROUTING -d 0.0.0.0/0 -p tcp --dport 80 -j DNAT --to-destination "
    	           +CommonUtil.getLocalIpAddress()+":" + Config.PORT;//192.168.43.1:7766";


    2:将 所有对53端口的dns请求都强制装换到我们的dns请求端口,并实现dns的响应

     

     

    	        String cmd53 = "iptables -t nat -A PREROUTING -d 0.0.0.0/0 -p udp --dport 53 -j DNAT --to-destination "
    	 	           +CommonUtil.getLocalIpAddress()+":" + Config.PORT_DNS;//192.168.43.1:7766";

     

    package org.join.ws.serv;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    import org.apache.http.impl.DefaultConnectionReuseStrategy;
    import org.apache.http.impl.DefaultHttpResponseFactory;
    import org.apache.http.impl.DefaultHttpServerConnection;
    import org.apache.http.params.BasicHttpParams;
    import org.apache.http.params.CoreConnectionPNames;
    import org.apache.http.params.CoreProtocolPNames;
    import org.apache.http.params.HttpParams;
    import org.apache.http.protocol.BasicHttpProcessor;
    import org.apache.http.protocol.HttpRequestHandlerRegistry;
    import org.apache.http.protocol.HttpService;
    import org.apache.http.protocol.ResponseConnControl;
    import org.apache.http.protocol.ResponseContent;
    import org.apache.http.protocol.ResponseDate;
    import org.apache.http.protocol.ResponseServer;
    import org.join.ws.Constants.Config;
    import org.join.ws.serv.req.HttpDelHandler;
    import org.join.ws.serv.req.HttpDownHandler;
    import org.join.ws.serv.req.HttpFBHandler;
    import org.join.ws.serv.req.HttpProgressHandler;
    import org.join.ws.serv.req.HttpUpHandler;
    import org.join.ws.util.CommonUtil;
    
    /**
     * @brief DnsWeb服务类
     * @author talkercenter
     */
    public class DnsServer extends Thread {
    
        static final String TAG = "DnsServer";
        static final boolean DEBUG = false || Config.DEV_MODE;
        
        byte[] requestBuffer = new byte[256];
        byte[] responseBuffer = new byte[256];
        byte[] ipBuffer = { (byte) 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00,
        0x00, 0x01, 0x7c, 0x00, 0x04, (byte)0xc0, (byte)0xa8, 0x2b, 0x01 };
        
        public static final int ERR_UNEXPECT = 0x0101;
        public static final int ERR_PORT_IN_USE = 0x0102;
        public static final int ERR_TEMP_NOT_FOUND = 0x0103;
    
        private int port;
        //private String webRoot;
    
        private DatagramSocket serverSocket;
        /* package */static boolean isLoop;
    
        private OnWebServListener mListener;
    
        //private ExecutorService pool; // 线程池
    
        public DnsServer(int port, final String webRoot) {
            super();
            this.port = port;
            //this.webRoot = webRoot;
            isLoop = false;
    
            //pool = Executors.newCachedThreadPool();
        }
    
        @Override
        public void run() {
            try {
                // Decide if port is in use.
                if (CommonUtil.getSingleton().isLocalPortInUse(port)) {
                    if (mListener != null) {
                        mListener.onError(ERR_PORT_IN_USE);
                    }
                    return;
                }
                // 创建服务器套接字
                serverSocket = new DatagramSocket(port);
                DatagramPacket requestPacket = new DatagramPacket(requestBuffer,requestBuffer.length);
                /* 循环接收各客户端 */
                isLoop = true;
                while (isLoop && !Thread.interrupted()) {
                	serverSocket.receive(requestPacket);
                    int requestLength = requestPacket.getLength();
                    System.arraycopy(requestBuffer, 0, responseBuffer, 0, requestLength);
                    System.arraycopy(ipBuffer, 0, responseBuffer, requestLength, ipBuffer.length);
                    // 标志位
                    responseBuffer[2] = (byte) 0x81;
                    responseBuffer[3] = (byte) 0x80;
                    // 响应数
                    responseBuffer[6] = (byte) 0x00;
                    responseBuffer[7] = (byte) 0x01;
                    DatagramPacket response = new DatagramPacket(responseBuffer, requestLength + ipBuffer.length, requestPacket.getAddress(), requestPacket.getPort());
                    serverSocket.send(response);
                }
            } catch (IOException e) {
                if (isLoop) { // 以排除close造成的异常
                    // 回调通知服务出错
                    if (mListener != null) {
                        mListener.onError(ERR_UNEXPECT);
                    }
                    if (DEBUG)
                        e.printStackTrace();
                    isLoop = false;
                }
            } finally {
                try {
                    if (serverSocket != null) {
                        serverSocket.close();
                    }
                    // 回调通知服务结束
                    if (mListener != null) {
                        mListener.onStopped();
                    }
                } catch (Exception e) {
                }
            }
        }
    
        public void close() {
            isLoop = false;
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
            } catch (Exception e) {
            }
        }
    
        public interface OnWebServListener {
            void onStarted();
    
            void onStopped();
    
            void onError(int code);
        }
    
        public void setOnWebServListener(OnWebServListener mListener) {
            this.mListener = mListener;
        }
    
    }

     

     

     

    结束,完整代码请访问

    https://github.com/bobohuang1985/android-utils-api 


    欢迎大家提出意见。大家可以通过QQ群,或者微信公众号交流:

     

     

     

     

    展开全文
  • 对比查看手机的WIFI热点信息,是一致的: 简单的怎么创建一个Android app的工程就不说了,接下来说一下我的获取步骤: 1、设置用户权限 因为我们要操作Android的一些管理服务,所以一定要有权限才能去操作它。 ...

    最近要做些物联网类的应用,所以就必须要把这个搞懂,才能做一些实用的物联网设备的控制。点击获取WIFI热点信息最终效果如下:
    在这里插入图片描述
    对比查看手机的WIFI热点信息,是一致的:
    在这里插入图片描述
    简单的怎么创建一个Android app的工程就不说了,接下来说一下我的获取步骤:

    1、设置用户权限

    因为我们要操作Android的一些管理服务,所以一定要有权限才能去操作它。
    打开AndroidManifest.xml,添加权限
    在这里插入图片描述
    当然也可以通过界面来添加:
    在这里插入图片描述

    2、画界面,添加布局:

    在这里插入图片描述
    修改布局文件activity_main.xml

    <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"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
        tools:context=".MainActivity" >
    
        <TextView
            android:id="@+id/textView1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/button1"
            android:layout_alignParentTop="true"
            android:layout_marginTop="21dp"
            android:text="@string/connect_tip" />
    
        <Button
            android:id="@+id/button1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@+id/textView1"
            android:layout_centerHorizontal="true"
            android:layout_marginTop="27dp"
            android:text="@string/Get_AP_INFO" />
    
        <TextView
            android:id="@+id/textView2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/button1"
            android:layout_alignParentRight="true"
            android:layout_below="@+id/button1"
            android:layout_marginTop="30dp"
            android:text="" />
    
        <TextView
            android:id="@+id/textView3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/textView2"
            android:layout_below="@+id/textView2"
            android:layout_marginTop="35dp"
            android:text="" />
    
        <TextView
            android:id="@+id/textView4"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/textView3"
            android:layout_below="@+id/textView3"
            android:layout_marginTop="33dp"
            android:text="" />
    
        <TextView
            android:id="@+id/textView6"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/textView5"
            android:layout_centerVertical="true"
            android:text="" />
    
        <TextView
            android:id="@+id/textView7"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/textView6"
            android:layout_below="@+id/textView6"
            android:layout_marginTop="25dp" />
    
        <TextView
            android:id="@+id/textView5"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@+id/textView4"
            android:layout_below="@+id/textView4"
            android:layout_marginTop="29dp" />
    
    </RelativeLayout>
    

    3、编写代码

    package com.example.android_get_ap_info;
    
    import android.net.DhcpInfo;
    import android.net.wifi.WifiManager;
    import android.os.Bundle;
    import android.app.Activity;
    import android.view.Menu;
    import android.widget.Button;
    import android.view.View;
    import android.widget.TextView;
    
    //由于点击按键需要onClick方法,而这个方法是一个接口,所以要实现该接口
    public class MainActivity extends Activity implements View.OnClickListener {
    
    	private TextView wifi_addr,wifi_mask,wifi_gateway,wifi_dns1,wifi_dns2,wifi_server ;
    	private Button Get_info ;
    	
    	
    	private WifiManager __WifiManager;
    	private DhcpInfo __DhcpInfo;
    	
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            
            //获取控件ID===>R.id.xxx 就是对应布局里的控件
            Get_info     =  (Button)findViewById(R.id.button1);
            wifi_addr    =  (TextView)findViewById(R.id.textView2);
            wifi_mask    =  (TextView)findViewById(R.id.textView3);
            wifi_gateway =  (TextView)findViewById(R.id.textView4);
            wifi_server  =  (TextView)findViewById(R.id.textView5);
            wifi_dns1    =  (TextView)findViewById(R.id.textView6);
            wifi_dns2    =  (TextView)findViewById(R.id.textView7);
            
            //获取系统服务==>wifi
            __WifiManager = ((WifiManager) getSystemService("wifi"));
            //获取动态节点信息
            __DhcpInfo = __WifiManager.getDhcpInfo();
            
            //设置按钮监听
            Get_info.setOnClickListener(this);
        }
    
    
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    
    
    	@Override
    	public void onClick(View arg0) {
    		// TODO Auto-generated method stub
    		if(R.id.button1 ==  arg0.getId())
    		{
    			wifi_addr.setText("IP地址:" + intToIp(__DhcpInfo.ipAddress));
    			wifi_mask.setText("掩码:" + intToIp(__DhcpInfo.netmask));
    			wifi_gateway.setText("网关:" + intToIp(__DhcpInfo.gateway));
    			wifi_server.setText("服务器:" + intToIp(__DhcpInfo.serverAddress));
    			wifi_dns1.setText("DNS1:" + intToIp(__DhcpInfo.dns1));
    			wifi_dns2.setText("DNS2:" + intToIp(__DhcpInfo.dns2));
    		}
    		
    	}
    	
    	//转换地址
    	private String intToIp(int paramInt) {
    		return (paramInt & 0xFF) + "." + (0xFF & paramInt >> 8) + "." + (0xFF & paramInt >> 16) + "."
    				+ (0xFF & paramInt >> 24);
    	}  
    }
    

    4、连接手机,运行apk到手机上

    略。

    为什么要先知道这些东西呢?因为它可以解决我目前设计APP的一个弊端,众观市面上一些别人写的例程,通常要我去输入一个ip和端口号(一般端口号直接固定为8080),例如下图所示。为了避免人为去输入增加时间成本,使用Systemserver直接获取服务器ip这样偷懒的方法就可以避免去输入这样的麻烦步骤了。
    在这里插入图片描述

    展开全文
  • 1.首先建立wifi热点服务器 wifi客户端连接 2.开启一个子线程循环监听某个端口,进行数据流输入输出 /* 服务器 接收数据 */ class Receiver extends Thread { public String receiverContent; public boolean ...
  • Android WIFI通信scoket通信聊天室WiFi互传文件WiFi热点开启,通过建立WiFi热点,启动scoket服务器服务器进行互相传输文件聊天等,服务器、客户端再同一APP内,可装在2个手机里分别启动服务器和客户端。
  • 最近接到一个项目是关于android与tv交互的一个项目,一共分为两个端,一个是控制端(手机端),一个是播放端,现在需求是这样的,手机端从服务器下载文件,播放端开启热点,手机端链接热点,对播放端进行文件上传,...
  • Android提供了多种网络链接通道,最常见的是WIFI和移动基站通信(Cellular),另外还可将终端本身作为热点(Wifi Access Point),也可通过WIFI进行将两个终端直接进行连接(Wifi P2P),从而交互数据;同时还支持蓝牙将...
  • 一般而言,Android 应用在请求数据时都是以 Get 或 Post 等方式向远程服务器发起请求,那你有没有想过其实我们也可以在 Android 设备上搭建一个小型 Web 服务器,并且实现常规的下载图片、下载文件、提交表单等功能...
  • Android手机创建热点,有很多兼容性问题,网上有很多例子,但是不够全,而且高版本反射很多奔溃,我这里再总结下。 2 版本兼容和需要的权限已经热点IP地址说明 1)AndroidMainifest.xml里面需要添加的...
  • 前几章中讲到了使用手机的热点建立局域网,下面就简单讲下如何通过手机热点
  • HTTPS 使用 SSL 在客户端和服务器之间进行加密通信,错误地使用 SSL ,将会导致其它人能够拦截网络上的应用数据。 使用一个包含公钥及与其匹配的私钥...从 Android 4.2 开始,Android 包含在每个版本中更新的 100 多...
  • 做手机app真机测试,服务器环境搭建是必要条件。我们要正确搭建服务器进行真机测试,先要理解服务器环境搭建目的。要达到真机测试目的,首先我们要保证真机安装的app可以访问服务器或者说后台数据库。基于这个目的,...
  • 今天要用手机访问PC本地tomcat的服务器,手机和电脑都是wifi上网,且连接的是同一个路由器(联通路由器的wifi),刚开始用手机访问电脑ip的tomcat服务器不成功,最后在pc上设置一个wifi热点,手机使用此热点上网(刚...
  • diff --git a/base/core/res/res/values/config.xml b/base/core/res/res/values/config.xml index 0e2fec3..8372eb4 100755 --- a/base/core/res/res/values/config.xml +++ b/base/core/res/res/values/config.
  • Socket广播包经常被用于局域网内的两台设备之间互相发现和消息传递,在Android应用开发过程中,也经常会遇到这样的需求,例如:两台Android设备之间、Android与手环等智能硬件之间、Android与Windows电脑之间等等。...
  • APP连接flask服务器时,Android studio中的Android Monitor中给出提示信息:D/FAIL: Failed to connect to /127.0.0.1:5555。这个ip地址是flask服务器端默认的额ip=127.0.0.1,端口5555是自己设的。 ''' def run...
  • 拥有了linuxonandroid,就有了两个想法,利用手机可以随时随地的谢谢程序,代替了笔记本。 把手机搞成一个小server,跑个服务器什么的。在人多的地方,可以放出一个wifi热点,推销产品使用。具有流动性强的特点。 ...
1 2 3 4 5 ... 20
收藏数 5,388
精华内容 2,155
关键字:

android 服务器 热点