control smart screen

@@ -43,11 +43,11 @@
         <activity
         <activity
                 android:name=".activity.StartActivity"
                 android:name=".activity.StartActivity"
                 android:theme="@style/AppStartTheme">
                 android:theme="@style/AppStartTheme">
-            <intent-filter>
+           <!-- <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
                 <action android:name="android.intent.action.MAIN"/>
 
 
                 <category android:name="android.intent.category.LAUNCHER"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
-            </intent-filter>
+            </intent-filter>-->
         </activity>
         </activity>
         <activity android:name=".activity.SearchNewActivity"/>
         <activity android:name=".activity.SearchNewActivity"/>
         <activity android:name=".activity.PlayListActivity"/>
         <activity android:name=".activity.PlayListActivity"/>
@@ -128,5 +128,15 @@
         </activity>
         </activity>
         <!--门禁相关服务，必要！！！-->
         <!--门禁相关服务，必要！！！-->
         <service android:name="com.bluetoothle.GREENBluetoothLeService" android:enabled="true"/>
         <service android:name="com.bluetoothle.GREENBluetoothLeService" android:enabled="true"/>
+
+        <activity android:name="com.xgimi.smartscreen.ConfigActivity"/>
+        <activity android:name="com.xgimi.smartscreen.MainActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+        <service android:name="com.xgimi.smartscreen.service.ConfigService"/>
     </application>
     </application>
 </manifest>
 </manifest>

@@ -19,7 +19,6 @@ import android.widget.Spinner;
 import android.widget.TableRow;
 import android.widget.TableRow;
 import android.widget.TextView;
 import android.widget.TextView;
 import android.widget.Toast;
 import android.widget.Toast;
-
 import com.gimi.common.cinema.model.SambaMsg;
 import com.gimi.common.cinema.model.SambaMsg;
 import com.gimi.common.cinema.utils.T;
 import com.gimi.common.cinema.utils.T;
 import com.gimi.common.cinema.utils.WifiApManger;
 import com.gimi.common.cinema.utils.WifiApManger;
@@ -28,6 +27,7 @@ import com.xgimi.gimicinema.BuildConfig;
 import com.xgimi.gimicinema.R;
 import com.xgimi.gimicinema.R;
 import com.xgimi.gimicinema.mview.ISettingView;
 import com.xgimi.gimicinema.mview.ISettingView;
 import com.xgimi.gimicinema.presenter.SettingPresenter;
 import com.xgimi.gimicinema.presenter.SettingPresenter;
+import com.xgimi.smartscreen.ConfigActivity;
 
 
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashMap;
@@ -326,4 +326,9 @@ public class SettingActivity extends BaseActivity implements ISettingView {
         Intent intent = new Intent(this, SwitchControlActivity.class);
         Intent intent = new Intent(this, SwitchControlActivity.class);
         startActivity(intent);
         startActivity(intent);
     }
     }
+
+    public void setSmartScreen(View view) {
+        Intent intent = new Intent(this, ConfigActivity.class);
+        startActivity(intent);
+    }
 }
 }

+package com.xgimi.smartscreen;
+
+import android.app.Activity;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.Toast;
+import com.xgimi.gimicinema.R;
+import com.xgimi.smartscreen.confignetwork.ChTask;
+import com.xgimi.smartscreen.confignetwork.IChListener;
+import com.xgimi.smartscreen.confignetwork.IChResult;
+import com.xgimi.smartscreen.confignetwork.IChTask;
+import com.xgimi.smartscreen.confignetwork.task.__IChTask;
+import com.xgimi.smartscreen.service.WifiAdminSimple;
+
+import java.util.List;
+
+public class ConfigActivity extends Activity {
+
+    private static final String TAG = "ConfigActivity";
+
+    private EditText mEdtApSsid;
+    private EditText mEdtApPassword;
+    private Button mBtnConfig;
+
+    private WifiAdminSimple mWifiAdmin;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_config);
+
+        mWifiAdmin = new WifiAdminSimple(this);
+
+        mEdtApSsid = (EditText) findViewById(R.id.ssid_et);
+        mEdtApPassword = (EditText) findViewById(R.id.pwd_et);
+
+        mEdtApSsid.setText("LEMOMOFFICE2.4G");
+        mEdtApPassword.setText("88888888");
+
+        mBtnConfig = (Button) findViewById(R.id.btn_save);
+        mBtnConfig.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                String apSsid = mEdtApSsid.getText().toString();
+                String apPassword = mEdtApPassword.getText().toString();
+                String apBssid = mWifiAdmin.getWifiConnectedBssid();
+
+                int[] tastResultCount = {0, 1, 2, 3, 4, 5};
+                String taskResultCountStr = Integer.toString(tastResultCount[1]); //设置任务的数量为1个
+
+                new AsyncTask3().execute(apSsid, apBssid, apPassword, "NO", taskResultCountStr);
+            }
+        });
+
+    }
+
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        // display the connected ap's ssid
+        String apSsid = mWifiAdmin.getWifiConnectedSsid();
+        if (apSsid != null) {
+            mEdtApSsid.setText(apSsid);
+        } else {
+            mEdtApSsid.setText("");
+        }
+//         check whether the wifi is connected
+        boolean isApSsidEmpty = TextUtils.isEmpty(apSsid);
+        mBtnConfig.setEnabled(!isApSsidEmpty);
+    }
+
+    public void matchScreen(View view) {
+        Intent intent = new Intent(this, MainActivity.class);
+        startActivity(intent);
+    }
+
+
+    private class AsyncTask2 extends AsyncTask<String, Void, IChResult> {
+
+        private ProgressDialog mProgressDialog;
+
+        private IChTask mChTask;
+        // without the lock, if the user tap confirm and cancel quickly enough,
+        // the bug will arise. the reason is follows:
+        // 0. task is starting created, but not finished
+        // 1. the task is cancel for the task hasn't been created, it do nothing
+        // 2. task is created
+        // 3. Oops, the task should be cancelled, but it is running
+        private final Object mLock = new Object();
+
+        @Override
+        protected void onPreExecute() {
+            mProgressDialog = new ProgressDialog(ConfigActivity.this);
+            mProgressDialog.setMessage("正在配置，请稍侯...");
+            mProgressDialog.setCanceledOnTouchOutside(false);
+            mProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+                @Override
+                public void onCancel(DialogInterface dialog) {
+                    synchronized (mLock) {
+                        if (__IChTask.DEBUG) {
+                            Log.i(TAG, "progress dialog is canceled");
+                        }
+                        if (mChTask != null) {
+                            mChTask.interrupt();
+                        }
+                    }
+                }
+            });
+            mProgressDialog.setButton(DialogInterface.BUTTON_POSITIVE, "确认", new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                }
+            });
+            mProgressDialog.show();
+            mProgressDialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(false);
+        }
+
+        @Override
+        protected IChResult doInBackground(String... params) {
+            synchronized (mLock) {
+                String apSsid = params[0];
+                String apBssid = params[1];
+                String apPassword = params[2];
+                String isSsidHiddenStr = params[3];
+                boolean isSsidHidden = false;
+                if (isSsidHiddenStr.equals("YES")) {
+                    isSsidHidden = true;
+                }
+                mChTask = new ChTask(apSsid, apBssid, apPassword, isSsidHidden, ConfigActivity.this);
+            }
+            IChResult result = mChTask.executeForResult();
+            return result;
+        }
+
+        @Override
+        protected void onPostExecute(IChResult result) {
+            mProgressDialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(true);
+            mProgressDialog.getButton(DialogInterface.BUTTON_POSITIVE).setText("确认");
+            // it is unnecessary at the moment, add here just to show how to use isCancelled()
+            if (!result.isCancelled()) {
+                if (result.isSuc()) {
+                    mProgressDialog.setMessage("配置成功" + "\n" + "BSSID = " + result.getBssid() + "\n" + "InetAddress = " + result.getInetAddress().getHostAddress());
+                } else {
+                    mProgressDialog.setMessage("配置失败");
+                }
+            }
+        }
+    }
+
+    private void onChResultAddedPerform(final IChResult result) {
+        runOnUiThread(new Runnable() {
+
+            @Override
+            public void run() {
+                String text = result.getBssid() + " 已连接到wifi";
+                Toast.makeText(ConfigActivity.this, text, Toast.LENGTH_SHORT).show();
+            }
+
+        });
+    }
+
+    private IChListener myListener = new IChListener() {
+
+        @Override
+        public void onChResultAdded(final IChResult result) {
+            onChResultAddedPerform(result);
+        }
+    };
+
+    private class AsyncTask3 extends AsyncTask<String, Void, List<IChResult>> {
+
+        private ProgressDialog mProgressDialog;
+
+        private IChTask mChTask;
+        // without the lock, if the user tap confirm and cancel quickly enough,
+        // the bug will arise. the reason is follows:
+        // 0. task is starting created, but not finished
+        // 1. the task is cancel for the task hasn't been created, it do nothing
+        // 2. task is created
+        // 3. Oops, the task should be cancelled, but it is running
+        private final Object mLock = new Object();
+
+        @Override
+        protected void onPreExecute() {
+            mProgressDialog = new ProgressDialog(ConfigActivity.this);
+            mProgressDialog.setMessage("正在配置, 请稍候...");
+            mProgressDialog.setCanceledOnTouchOutside(false);
+            mProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+                @Override
+                public void onCancel(DialogInterface dialog) {
+                    synchronized (mLock) {
+                        if (__IChTask.DEBUG) {
+                            Log.i(TAG, "progress dialog is canceled");
+                        }
+                        if (mChTask != null) {
+                            mChTask.interrupt();
+                        }
+                    }
+                }
+            });
+            mProgressDialog.setButton(DialogInterface.BUTTON_POSITIVE, "确认", new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                }
+            });
+            if (!mProgressDialog.isShowing()) {
+                mProgressDialog.show();
+                mProgressDialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(false);
+            }
+        }
+
+        @Override
+        protected List<IChResult> doInBackground(String... params) {
+            int taskResultCount = -1;
+            synchronized (mLock) {
+                String apSsid = params[0];
+                String apBssid = params[1];
+                String apPassword = params[2];
+                String isSsidHiddenStr = params[3];
+                String taskResultCountStr = params[4];
+                boolean isSsidHidden = false;
+                if (isSsidHiddenStr.equals("YES")) {
+                    isSsidHidden = true;
+                }
+                taskResultCount = Integer.parseInt(taskResultCountStr);
+                mChTask = new ChTask(apSsid, apBssid, apPassword, isSsidHidden, ConfigActivity.this);
+                mChTask.setChListener(myListener);
+            }
+            List<IChResult> resultList = mChTask.executeForResults(taskResultCount);
+            return resultList;
+        }
+
+        @Override
+        protected void onPostExecute(List<IChResult> result) {
+            mProgressDialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(true);
+            mProgressDialog.getButton(DialogInterface.BUTTON_POSITIVE).setText("确认");
+            IChResult firstResult = result.get(0);
+            // check whether the task is cancelled and no results received
+            if (!firstResult.isCancelled()) {
+                int count = 0;
+                // max results to be displayed, if it is more than maxDisplayCount,
+                // just show the count of redundant ones
+                final int maxDisplayCount = 5;
+                // the task received some results including cancelled while
+                // executing before receiving enough results
+                if (firstResult.isSuc()) {
+                    StringBuilder sb = new StringBuilder();
+                    for (IChResult resultInList : result) {
+                        sb.append("配置成功" + "\n" + "BSSID = " + resultInList.getBssid() + "\n" + "InetAddress = " + resultInList.getInetAddress().getHostAddress());
+
+                        count++;
+                        if (count >= maxDisplayCount) {
+                            break;
+                        }
+                    }
+                    if (count < result.size()) {
+                        sb.append("\n有 " + (result.size() - count) + " 个结果未显示\n");
+                    }
+                    mProgressDialog.setMessage(sb.toString());
+                } else {
+                    mProgressDialog.setMessage("配置失败");
+                }
+            }
+        }
+
+    }
+}

+package com.xgimi.smartscreen;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.text.method.ScrollingMovementMethod;
+import android.util.Log;
+import android.view.View;
+import android.widget.TextView;
+import android.widget.Toast;
+import com.xgimi.gimicinema.R;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+
+
+public class ControlDialog extends Dialog implements View.OnClickListener {
+    private static final String TAG = "ControlDialog";
+
+    private Context mContext;
+    private String mDeviceIp;
+
+    private TextView tvDeviceInfo;
+
+    private MessageThread messageThread;
+    private static final int PORT = 8009;
+
+    public ControlDialog(Context context, String DeviceIp) {
+        super(context);
+
+        this.mContext = context;
+        this.mDeviceIp = DeviceIp;
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.dialog_control);
+
+        TextView tvDeviceIp = (TextView) findViewById(R.id.tv_dialog_ip);
+        tvDeviceIp.setText("[ " + mDeviceIp + " ]");
+
+        tvDeviceInfo = (TextView) findViewById(R.id.tv_device_info);
+        tvDeviceInfo.setMovementMethod(ScrollingMovementMethod.getInstance());
+        tvDeviceInfo.setText("序列号：\n\n软件版本：\n\n硬件版本：\n\n幕布状态：");
+
+        TextView tvUp = (TextView) findViewById(R.id.tv_up);
+        tvUp.setOnClickListener(this);
+
+        TextView tvDown = (TextView) findViewById(R.id.tv_down);
+        tvDown.setOnClickListener(this);
+
+
+        messageThread = new MessageThread();
+
+        new Thread(messageThread).start();
+
+        new Handler().postDelayed(new Runnable() {
+            public void run() {
+                getDeviceInfo();
+            }
+        }, 1000);
+
+    }
+
+    private void getDeviceInfo() {
+        JSONObject dataGetInfo = new JSONObject();
+
+        try {
+            dataGetInfo.put("cmd", 1);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+
+        Message msgGetInfo = new Message();
+        msgGetInfo.what = 0x345;
+        msgGetInfo.obj = dataGetInfo;
+        messageThread.sendHandler.sendMessage(msgGetInfo);
+    }
+
+    @Override
+    public void onClick(View v) {
+        switch (v.getId()) {
+            case R.id.tv_up:/*
+
+
+                MessageEvent msgEvent = new MessageEvent();
+                msgEvent.setEventId(SmartScreenBean.UPACTION);
+                msgEvent.setMessage("192.168.31.164");
+                EventBus.getDefault().post(msgEvent);*/
+                JSONObject dataUp = new JSONObject();
+                getDeviceInfo();
+                try {
+                    dataUp.put("cmd", 2);
+                    dataUp.put("action", 0);
+                } catch (JSONException e) {
+                    e.printStackTrace();
+                }
+
+                Message msgUp = new Message();
+                msgUp.what = 0x345;
+                msgUp.obj = dataUp;
+                messageThread.sendHandler.sendMessage(msgUp);
+
+                break;
+
+            case R.id.tv_down:
+
+               /* MessageEvent msgEvent1 = new MessageEvent();
+                msgEvent1.setEventId(SmartScreenBean.DOWNACTION);
+                msgEvent1.setMessage("192.168.31.164");
+                EventBus.getDefault().post(msgEvent1);*/
+                JSONObject dataDown = new JSONObject();
+
+                try {
+                    dataDown.put("cmd", 2);
+                    dataDown.put("action", 1);
+                } catch (JSONException e) {
+                    e.printStackTrace();
+                }
+
+                Message msgDown = new Message();
+                msgDown.what = 0x345;
+                msgDown.obj = dataDown;
+                messageThread.sendHandler.sendMessage(msgDown);
+
+                break;
+        }
+    }
+
+    Handler handler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            super.handleMessage(msg);
+
+            if (msg.what == 0x123) {
+                String data = (msg.obj).toString();
+
+                try {
+                    JSONObject jsonObject = new JSONObject(data);
+
+                    int cmd = jsonObject.getInt("cmd");
+
+                    if (cmd == 1) {
+                        int sn = jsonObject.getInt("sn");
+                        String swver = jsonObject.getString("swver");
+                        String hdver = jsonObject.getString("hdver");
+
+                        tvDeviceInfo.setText("序列号：" + sn + "\n\n软件版本：" + swver + "\n\n硬件版本：" + hdver);
+
+                    } else if (cmd == 2) {
+                        int result = jsonObject.getInt("result");
+                        if (result == 1) { //成功
+                            Toast.makeText(mContext, "操作成功", Toast.LENGTH_SHORT).show();
+                        } else if (result == 0) {  //失败
+                            Toast.makeText(mContext, "操作失败", Toast.LENGTH_SHORT).show();
+                        }
+                    }
+
+                } catch (JSONException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    };
+
+
+    public class MessageThread implements Runnable {
+        //接收UI线程消息的Handler对象
+        public Handler sendHandler;
+
+        private Socket socket;
+        BufferedReader br = null;
+        PrintWriter pw = null;
+
+        @Override
+        public void run() {
+
+            try {
+                socket = new Socket(mDeviceIp, PORT);
+                br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+                pw = new PrintWriter(socket.getOutputStream());
+
+                //启动一个线程来读取数据
+                new Thread(new Runnable() {
+                    @Override
+                    public void run() {
+
+                        String data = null;
+
+                        try {
+                            while ((data = br.readLine()) != null) {
+                                Log.i(TAG, "接收到的数据：" + data);
+
+                                Message msg = new Message();
+                                msg.what = 0x123;
+                                msg.obj = data;
+                                handler.sendMessage(msg);
+                            }
+
+                        } catch (IOException e) {
+                            Log.i(TAG, "接收数据异常:" + e.getMessage());
+                            e.printStackTrace();
+                        }
+
+                    }
+                }).start();
+
+                Looper.prepare();
+                sendHandler = new Handler() {
+                    @Override
+                    public void handleMessage(Message msg) {
+                        super.handleMessage(msg);
+
+                        if (msg.what == 0x345) {
+                            Log.i(TAG, "写数据：" + (msg.obj).toString());
+//                            pw.write((msg.obj).toString());
+                            pw.write("{\"cmd\":2,\"action\":0}");
+                            pw.flush();
+                        }
+                    }
+                };
+                //启动Looper
+                Looper.loop();
+
+            } catch (SocketTimeoutException e) {
+                Log.i(TAG, "网络连接超时！");
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                try {
+                    if (pw != null) {
+                        pw.close();
+                    }
+                    if (br != null) {
+                        br.close();
+                    }
+                    if (socket != null) {
+                        socket.close();
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        }
+    }
+}

+package com.xgimi.smartscreen;
+
+import android.app.Activity;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+import android.view.Window;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+import android.widget.Toast;
+import com.xgimi.gimicinema.R;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainActivity extends Activity {
+    private static final String TAG = "MainActivity";
+
+    private ListView lvDevice;
+    List<String> listData;
+    ArrayAdapter<String> adapter;
+
+//    private SwipeRefreshLayout swipeRefreshLayout;
+
+    private boolean isSearching = false;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.content_main);
+//        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
+//        setSupportActionBar(toolbar);
+
+//        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
+//        fab.setOnClickListener(new View.OnClickListener() {
+//            @Override
+//            public void onClick(View view) {
+//                startActivity(new Intent(MainActivity.this, ConfigActivity.class));
+//            }
+//        });
+
+//        swipeRefreshLayout = (SwipeRefreshLayout) findViewById(R.id.swipeRefreshLayout);
+//
+//        swipeRefreshLayout.setColorSchemeResources(R.color.g);
+//        swipeRefreshLayout.setSize(SwipeRefreshLayout.LARGE);
+//
+//        swipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
+//            @Override
+//            public void onRefresh() {
+//            }
+//        });
+
+        lvDevice = (ListView) findViewById(R.id.lv_device);
+        lvDevice.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+            @Override
+            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+                ControlDialog dialog = new ControlDialog(MainActivity.this, listData.get(position));
+                dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);  //去除标题栏
+                dialog.show();
+            }
+        });
+        new SearchAsyncTask().execute();
+
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        isSearching = false;
+
+//        swipeRefreshLayout.setRefreshing(false);
+    }
+
+    private class SearchAsyncTask extends AsyncTask<Void, Integer, String> {
+
+        InetAddress deviceAddress = null;
+        DatagramSocket socket = null;
+
+        @Override
+        protected String doInBackground(Void... params) {
+            isSearching = true;
+
+            try {
+                socket = new DatagramSocket();
+            } catch (SocketException e) {
+                e.printStackTrace();
+            }
+
+            //接收
+            Thread receiveThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+
+                    byte[] dataReceive = new byte[1024];
+                    DatagramPacket packetReceive = new DatagramPacket(dataReceive, dataReceive.length);
+
+                    try {
+                        socket.receive(packetReceive);
+
+                        String reply = new String(dataReceive, 0, packetReceive.getLength());
+                        if (reply.contains("I'm a screen Controller")) {
+                            isSearching = false;
+
+                            deviceAddress = packetReceive.getAddress();
+                        }
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+
+            });
+
+            receiveThread.start();
+
+            int cnt = 3; //搜索次数
+
+            while (isSearching) {
+                Log.i(TAG, "开始搜索...");
+
+                if (--cnt == 0) {
+                    break;
+                }
+
+                //发送
+                String data = "Are You Screen Controller?";
+
+                DatagramPacket packetSend = null;
+                try {
+                    packetSend = new DatagramPacket(data.getBytes(), data.getBytes().length,
+                            InetAddress.getByName("255.255.255.255"), 12419);
+                } catch (UnknownHostException e) {
+                    e.printStackTrace();
+                }
+
+                try {
+                    socket.send(packetSend);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            receiveThread.interrupt();
+
+            if (deviceAddress != null) {
+                return deviceAddress.toString().substring(1);  //去除ip地址前的斜杠
+            } else {
+                return null;
+            }
+        }
+
+        @Override
+        protected void onPreExecute() {
+            super.onPreExecute();
+
+//            swipeRefreshLayout.setRefreshing(true);
+
+            if (lvDevice.getCount() != 0) {
+                adapter.clear();
+                adapter.notifyDataSetChanged();
+            }
+        }
+
+        @Override
+        protected void onPostExecute(String s) {
+            super.onPostExecute(s);
+
+//            swipeRefreshLayout.setRefreshing(false);
+
+            if (s != null) {
+                listData = new ArrayList<String>();
+                listData.add(s);
+
+                adapter = new ArrayAdapter<String>(MainActivity.this, android.R.layout.simple_list_item_1, listData);
+                lvDevice.setAdapter(adapter);
+            } else {
+                Toast.makeText(MainActivity.this, "没有搜索到设备,再次下拉搜索", Toast.LENGTH_SHORT).show();
+            }
+        }
+    }
+
+}

+package com.xgimi.smartscreen;
+
+/**
+ * Created by Administrator on 2016/10/15.
+ */
+public class SmartScreenBean {
+    public static final int UPACTION = 0;
+    public static final int DOWNACTION = 1;
+    public static final int STOPACTION = 2;
+
+    public String ip;
+    public String name;
+    public int state;
+
+}

+package com.xgimi.smartscreen;
+
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.util.Log;
+import com.gimi.common.cinema.model.MessageEvent;
+import com.gimi.common.cinema.utils.SystemUtils;
+import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
+import com.qnbar.smc.service.SocketResponse;
+import com.qnbar.smc.service.SocketSendMsg;
+import com.xgimi.gimicinema.BuildConfig;
+import org.greenrobot.eventbus.EventBus;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.ref.WeakReference;
+import java.net.Socket;
+import java.util.Arrays;
+
+public class SocketService extends Service {
+    private static final String TAG = "BackService";
+    private static final long HEART_BEAT_RATE = 10 * 1000;
+
+    public static final int OPEN_DOOR_CMD = 1701;
+
+    private static final int SUCESS_MESSAGE = 0;
+    private static final int ROOM_HAS_REGISTERED = 1001;
+    private static final int ROOM_NOT_EXIST_M = 1002;
+    private static final int HEAT_BEAT_RTN = 1003;
+
+    public static final String HOST = "121.43.189.162";// "192.168.1.21";//
+    public static final int PORT = 9501;
+
+    public static final String END_SYMBOL = "\\r\\n\\r\\n";//心跳包内容
+    public String testRoomSn = "000003";
+
+    private ReadThread mReadThread;
+    private HeatBeatThread mHeatBeatThread;
+    private Gson gson;
+
+//    private LocalBroadcastManager mLocalBroadcastManager;
+
+    private WeakReference<Socket> mSocket;
+
+    // For heart Beat
+//    private Handler mHandler = new Handler();
+//    private Runnable heartBeatRunnable = new Runnable() {
+//
+//        @Override
+//        public void run() {
+//            if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {
+//                Log.d(TAG, "heart beat");
+//                boolean isSuccess = sendMsg(new Gson().toJson(new SocketSendMsg().contractHeartBeatMsg(testRoomSn)) + END_SYMBOL);//就发送一个HEART_BEAT_STRING过去 如果发送失败，就重新初始化一个socket
+//                if (!isSuccess) {
+//                    Log.d(TAG, "heart beat error restart");
+//                    mHandler.removeCallbacks(heartBeatRunnable);
+//                    mReadThread.release();
+//                    mHeatBeatThread.release();
+//                    releaseLastSocket(mSocket);
+//                    new InitSocketThread().start();
+//                }
+//            } else {
+//                Log.d(TAG, "heart beat less than beat rate");
+//            }
+//            mHandler.postDelayed(this, HEART_BEAT_RATE);
+//        }
+//    };
+
+    private long sendTime = 0L;
+    private Context context;
+
+    @Override
+    public IBinder onBind(Intent arg0) {
+        return null;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        gson = new Gson();
+        context = this;
+        //TODO change the room sn
+        if (!"LETEST".equals(SystemUtils.getPid(context, BuildConfig.MACHINE_TYPE))) {
+            testRoomSn = "000002";
+        }
+        new InitSocketThread().start();
+        Log.d(TAG, "socket service onCreate");
+    }
+
+    public boolean sendMsg(String msg) {
+        if (null == mSocket || null == mSocket.get()) {
+            return false;
+        }
+        Log.d(TAG, "send msg:" + msg);
+        Socket soc = mSocket.get();
+        try {
+            if (!soc.isClosed() && !soc.isOutputShutdown()) {
+                OutputStream os = soc.getOutputStream();
+                String message = msg;
+                os.write(message.getBytes());
+                os.flush();
+                sendTime = System.currentTimeMillis();//每次发送成数据，就改一下最后成功发送的时间，节省心跳间隔时间
+            } else {
+                return false;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+            return false;
+        }
+        return true;
+    }
+
+    private void initSocket() throws IOException {//初始化Socket
+        Socket so = new Socket(HOST, PORT);
+        mSocket = new WeakReference<Socket>(so);
+        mReadThread = new ReadThread(so);
+        mReadThread.start();
+//            new Thread(heartBeatRunnable).start();
+//            mHandler.post(heartBeatRunnable);//初始化成功后，就准备发送心跳包
+        mHeatBeatThread = new HeatBeatThread(so);
+        mHeatBeatThread.start();//上面的 one plus 3t NetworkOnMainThreadException!!!
+    }
+
+    private void releaseLastSocket(WeakReference<Socket> mSocket) {
+        try {
+            if (null != mSocket) {
+                Socket sk = mSocket.get();
+                if (!sk.isClosed()) {
+                    sk.close();
+                }
+                sk = null;
+                mSocket = null;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    class InitSocketThread extends Thread {
+        @Override
+        public void run() {
+            super.run();
+            try {
+                initSocket();
+            } catch (IOException e) {
+                e.printStackTrace();
+                Log.d(TAG, "init socket thread error,restart again after 10's");
+                try {
+                    Thread.sleep(HEART_BEAT_RATE);
+                } catch (InterruptedException e1) {
+                    e1.printStackTrace();
+                }
+                this.run();
+            }
+        }
+    }
+
+    // Thread to read content from Socket
+    class ReadThread extends Thread {
+        private WeakReference<Socket> mWeakSocket;
+        private boolean isStart = true;
+
+        public ReadThread(Socket socket) {
+            mWeakSocket = new WeakReference<Socket>(socket);
+        }
+
+        public void release() {
+            isStart = false;
+            releaseLastSocket(mWeakSocket);
+        }
+
+        @Override
+        public void run() {
+            super.run();
+            Socket socket = mWeakSocket.get();
+            if (null != socket) {
+                try {
+                    if (!sendRegister) {
+                        Log.d(TAG, "send register mes");
+                        SocketSendMsg ssm = new SocketSendMsg().contractRegisterMsg(testRoomSn);
+                        String msg = gson.toJson(ssm) + END_SYMBOL;
+                        sendMsg(msg);
+                        Log.d(TAG, "" + msg);
+                        sendRegister = true;
+                    }
+                    Log.d(TAG, "send register mes end");
+                    InputStream is = socket.getInputStream();
+                    byte[] buffer = new byte[1024 * 4];
+                    int length = 0;
+                    while (!socket.isClosed() && !socket.isInputShutdown()
+                            && isStart && ((length = is.read(buffer)) != -1)) {
+                        if (length > 0) {
+                            String message = new String(Arrays.copyOf(buffer,
+                                    length)).trim();
+                            Log.d(TAG, "end:" + message.contains(END_SYMBOL) + "");
+                            Log.d(TAG, "recv msg:" + message);
+                            try {
+                                SocketResponse socketResponse = gson.fromJson(message.trim(), SocketResponse.class);
+                                switch (socketResponse.getCode()) {
+                                    case SUCESS_MESSAGE:
+                                        Log.d(TAG, "success:" + socketResponse.getCmd());
+                                        break;
+                                    case ROOM_HAS_REGISTERED:
+                                        SocketSendMsg ssm = new SocketSendMsg().contractReconnectMsg(testRoomSn);
+                                        String msg = gson.toJson(ssm) + END_SYMBOL;
+                                        sendMsg(msg);
+                                        Log.d(TAG, "send reconnect mes: " + msg);
+                                        break;
+                                    case ROOM_NOT_EXIST_M:
+                                        Log.d(TAG, "re init socket");
+                                        //sendRegister = false;
+                                        releaseLastSocket(mWeakSocket);
+                                        initSocket();
+                                        break;
+                                    case HEAT_BEAT_RTN:
+                                        Log.d(TAG, "HEAT_BEAT_RTN");
+                                        sendTime = System.currentTimeMillis();
+                                        break;
+                                }
+                                if (("openDoor").equals(socketResponse.getCmd())) {
+                                    MessageEvent messageEvent = new MessageEvent();
+                                    messageEvent.setEventId(OPEN_DOOR_CMD);
+                                    messageEvent.setMessage("click item");
+                                    EventBus.getDefault().post(messageEvent);
+                                }
+                            } catch (JsonSyntaxException e) {
+                                Log.d(TAG, message);
+                                e.printStackTrace();
+                            }
+                            //收到服务器过来的消息，就通过Broadcast发送出去
+//                            if (message.equals(END_SYMBOL)) {//处理心跳回复
+//                                Intent intent = new Intent(HEART_BEAT_ACTION);
+//                                mLocalBroadcastManager.sendBroadcast(intent);
+//                            } else {
+//                                //其他消息回复
+//                                Intent intent = new Intent(MESSAGE_ACTION);
+//                                intent.putExtra("message", message);
+//                                mLocalBroadcastManager.sendBroadcast(intent);
+//                            }
+                        }
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    boolean sendRegister = false;
+
+
+    // Thread to read content from Socket
+    class HeatBeatThread extends Thread {
+        private WeakReference<Socket> mWeakSocket;
+        private boolean isStart = true;
+
+        public HeatBeatThread(Socket socket) {
+            mWeakSocket = new WeakReference<Socket>(socket);
+        }
+
+        public void release() {
+            isStart = false;
+            releaseLastSocket(mWeakSocket);
+        }
+
+        @Override
+        public void run() {
+            super.run();
+            Socket socket = mWeakSocket.get();
+            if (null != socket) {
+                while (isStart) {
+                    if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {
+                        Log.d(TAG, "heart beat:" + Thread.currentThread().getId());
+                        boolean isSuccess = sendMsg(new Gson().toJson(new SocketSendMsg().contractHeartBeatMsg(testRoomSn)) + END_SYMBOL);//就发送一个HEART_BEAT_STRING过去 如果发送失败，就重新初始化一个socket
+                        if (!isSuccess) {
+                            Log.d(TAG, "heart beat error restart:" + Thread.currentThread().getId());
+//                            mHandler.removeCallbacks(heartBeatRunnable);
+                            mReadThread.release();
+                            mHeatBeatThread.release();
+                            sendRegister = false;
+                            releaseLastSocket(mSocket);
+                            new InitSocketThread().start();
+                        }
+                    } else {
+                        Log.d(TAG, "heart beat less than beat rate:" + Thread.currentThread().getId());
+                    }
+                    try {
+                        Thread.sleep(HEART_BEAT_RATE);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        Log.d(TAG, "socket service destroy");
+    }
+}

+package com.xgimi.smartscreen.confignetwork;
+
+import java.net.InetAddress;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class ChResult implements IChResult {
+
+    private final boolean mIsSuc;
+    private final String mBssid;
+    private final InetAddress mInetAddress;
+    private AtomicBoolean mIsCancelled;
+
+    /**
+     * Constructor of ChResult
+     *
+     * @param isSuc       whether the ch task is executed suc
+     * @param bssid       the device's bssid
+     * @param inetAddress the device's ip address
+     */
+    public ChResult(boolean isSuc, String bssid, InetAddress inetAddress) {
+        this.mIsSuc = isSuc;
+        this.mBssid = bssid;
+        this.mInetAddress = inetAddress;
+        this.mIsCancelled = new AtomicBoolean(false);
+    }
+
+    @Override
+    public boolean isSuc() {
+        return this.mIsSuc;
+    }
+
+    @Override
+    public String getBssid() {
+        return this.mBssid;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return mIsCancelled.get();
+    }
+
+    public void setIsCancelled(boolean isCancelled) {
+        this.mIsCancelled.set(isCancelled);
+    }
+
+    @Override
+    public InetAddress getInetAddress() {
+        return this.mInetAddress;
+    }
+
+}

+package com.xgimi.smartscreen.confignetwork;
+
+import android.content.Context;
+
+import com.xgimi.smartscreen.confignetwork.task.ChTaskParameter;
+import com.xgimi.smartscreen.confignetwork.task.IChTaskParameter;
+import com.xgimi.smartscreen.confignetwork.task.__ChTask;
+
+import java.util.List;
+
+
+public class ChTask implements IChTask {
+
+    public __ChTask _mChTask;
+    private IChTaskParameter _mParameter;
+
+    /**
+     * Constructor of ChTask
+     *
+     * @param apSsid       the Ap's ssid
+     * @param apBssid      the Ap's bssid
+     * @param apPassword   the Ap's password
+     * @param isSsidHidden whether the Ap's ssid is hidden
+     * @param context      the Context of the Application
+     */
+    public ChTask(String apSsid, String apBssid, String apPassword, boolean isSsidHidden, Context context) {
+        _mParameter = new ChTaskParameter();
+        _mChTask = new __ChTask(apSsid, apBssid, apPassword, context, _mParameter, isSsidHidden);
+    }
+
+    /**
+     * Constructor of ChTask
+     *
+     * @param apSsid             the Ap's ssid
+     * @param apBssid            the Ap's bssid
+     * @param apPassword         the Ap's password
+     * @param isSsidHidden       whether the Ap's ssid is hidden
+     * @param timeoutMillisecond (it should be >= 15000+6000) millisecond of total timeout
+     * @param context            the Context of the Application
+     */
+    public ChTask(String apSsid, String apBssid, String apPassword, boolean isSsidHidden, int timeoutMillisecond, Context context) {
+        _mParameter = new ChTaskParameter();
+        _mParameter.setWaitUdpTotalMillisecond(timeoutMillisecond);
+        _mChTask = new __ChTask(apSsid, apBssid, apPassword, context, _mParameter, isSsidHidden);
+    }
+
+    @Override
+    public void interrupt() {
+        _mChTask.interrupt();
+    }
+
+    @Override
+    public IChResult executeForResult() throws RuntimeException {
+        return _mChTask.executeForResult();
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return _mChTask.isCancelled();
+    }
+
+    @Override
+    public List<IChResult> executeForResults(int expectTaskResultCount) throws RuntimeException {
+        if (expectTaskResultCount <= 0) {
+            expectTaskResultCount = Integer.MAX_VALUE;
+        }
+        return _mChTask.executeForResults(expectTaskResultCount);
+    }
+
+    @Override
+    public void setChListener(IChListener chListener) {
+        _mChTask.setChListener(chListener);
+    }
+}

+package com.xgimi.smartscreen.confignetwork;
+
+public interface IChListener {
+    /**
+     * when new ch result is added, the listener will call
+     * onChResultAdded callback
+     *
+     * @param result the Ch result
+     */
+    void onChResultAdded(IChResult result);
+}

+package com.xgimi.smartscreen.confignetwork;
+
+import java.net.InetAddress;
+
+public interface IChResult {
+
+    /**
+     * check whether the ch task is executed suc
+     *
+     * @return whether the ch task is executed suc
+     */
+    boolean isSuc();
+
+    /**
+     * get the device's bssid
+     *
+     * @return the device's bssid
+     */
+    String getBssid();
+
+    /**
+     * check whether the ch task is cancelled by user
+     *
+     * @return whether the ch task is cancelled by user
+     */
+    boolean isCancelled();
+
+    /**
+     * get the ip address of the device
+     *
+     * @return the ip device of the device
+     */
+    InetAddress getInetAddress();
+}

+package com.xgimi.smartscreen.confignetwork;
+
+import java.util.List;
+
+public interface IChTask {
+
+    /**
+     * set the ch listener, when one device is connected to the Ap, it will be called back
+     *
+     * @param chListener when one device is connected to the Ap, it will be called back
+     */
+    void setChListener(IChListener chListener);
+
+    /**
+     * Interrupt the Ch Task when User tap back or close the Application.
+     */
+    void interrupt();
+
+    /**
+     * Note: !!!Don't call the task at UI Main Thread or RuntimeException will
+     * be thrown Execute the Ch Task and return the result
+     * <p/>
+     * Smart Config v2.4 support the API
+     *
+     * @return the IChResult
+     * @throws RuntimeException
+     */
+    IChResult executeForResult() throws RuntimeException;
+
+    /**
+     * Note: !!!Don't call the task at UI Main Thread or RuntimeException will
+     * be thrown Execute the Ch Task and return the result
+     * <p/>
+     * Smart Config v2.4 support the API
+     * <p/>
+     * It will be blocked until the client receive result count >= expectTaskResultCount.
+     * If it fail, it will return one fail result will be returned in the list.
+     * If it is cancelled while executing,
+     * if it has received some results, all of them will be returned in the list.
+     * if it hasn't received any results, one cancel result will be returned in the list.
+     *
+     * @param expectTaskResultCount the expect result count(if expectTaskResultCount <= 0,
+     *                              expectTaskResultCount = Integer.MAX_VALUE)
+     * @return the list of IChResult
+     * @throws RuntimeException
+     */
+    List<IChResult> executeForResults(int expectTaskResultCount) throws RuntimeException;
+
+    /**
+     * check whether the task is cancelled by user
+     *
+     * @return whether the task is cancelled by user
+     */
+    boolean isCancelled();
+}

+package com.xgimi.smartscreen.confignetwork.protocol;
+
+import com.xgimi.smartscreen.confignetwork.task.IChGenerator;
+import com.xgimi.smartscreen.confignetwork.util.ByteUtil;
+
+import java.net.InetAddress;
+
+
+public class ChGenerator implements IChGenerator {
+
+    private final byte[][] mGcBytes2;
+    private final byte[][] mDcBytes2;
+
+    /**
+     * Constructor of ChGenerator, it will cost some time(maybe a bit
+     * much)
+     *
+     * @param apSsid      the Ap's ssid
+     * @param apBssid     the Ap's bssid
+     * @param apPassword  the Ap's password
+     * @param inetAddress the phone's or pad's local ip address allocated by Ap
+     * @param isSsidHiden whether the Ap's ssid is hidden
+     */
+    public ChGenerator(String apSsid, String apBssid, String apPassword, InetAddress inetAddress, boolean isSsidHiden) {
+        // generate guide code
+        GuideCode gc = new GuideCode();
+        char[] gcU81 = gc.getU8s();
+        mGcBytes2 = new byte[gcU81.length][];
+
+        for (int i = 0; i < mGcBytes2.length; i++) {
+            mGcBytes2[i] = ByteUtil.genSpecBytes(gcU81[i]);
+        }
+
+        // generate data code
+        DatumCode dc = new DatumCode(apSsid, apBssid, apPassword, inetAddress,
+                isSsidHiden);
+        char[] dcU81 = dc.getU8s();
+        mDcBytes2 = new byte[dcU81.length][];
+
+        for (int i = 0; i < mDcBytes2.length; i++) {
+            mDcBytes2[i] = ByteUtil.genSpecBytes(dcU81[i]);
+        }
+    }
+
+    @Override
+    public byte[][] getGCBytes2() {
+        return mGcBytes2;
+    }
+
+    @Override
+    public byte[][] getDCBytes2() {
+        return mDcBytes2;
+    }
+
+}

+package com.xgimi.smartscreen.confignetwork.protocol;
+
+
+import com.xgimi.smartscreen.confignetwork.task.ICodeData;
+import com.xgimi.smartscreen.confignetwork.util.ByteUtil;
+import com.xgimi.smartscreen.confignetwork.util.CRC8;
+
+/**
+ * one data format:(data code should have 2 to 65 data)
+ * 
+ *              control byte       high 4 bits    low 4 bits 
+ * 1st 9bits:       0x0             crc(high)      data(high)
+ * 2nd 9bits:       0x1                sequence header
+ * 3rd 9bits:       0x0             crc(low)       data(low)
+ * 
+ * sequence header: 0,1,2,...
+ * 
+ * @author afunx
+ * 
+ */
+public class DataCode implements ICodeData {
+	
+	public static final int DATA_CODE_LEN = 6;
+	
+	private static final int INDEX_MAX = 127;
+	
+	private final byte mSeqHeader;
+    private final byte mDataHigh;
+    private final byte mDataLow;
+    // the crc here means the crc of the data and sequence header be transformed
+    // it is calculated by index and data to be transformed
+    private final byte mCrcHigh;
+    private final byte mCrcLow;
+	
+    /**
+     * Constructor of DataCode
+     * @param u8 the character to be transformed
+     * @param index the index of the char
+     */
+	public DataCode(char u8, int index) {
+		if (index > INDEX_MAX) {
+			throw new RuntimeException("index > INDEX_MAX");
+		}
+		byte[] dataBytes = ByteUtil.splitUint8To2bytes(u8);
+		mDataHigh = dataBytes[0];
+		mDataLow = dataBytes[1];
+		CRC8 crc8 = new CRC8();
+		crc8.update(ByteUtil.convertUint8toByte(u8));
+		crc8.update(index);
+		byte[] crcBytes = ByteUtil.splitUint8To2bytes((char) crc8.getValue());
+		mCrcHigh = crcBytes[0];
+		mCrcLow = crcBytes[1];
+		mSeqHeader = (byte) index;
+	}
+	
+	@Override
+	public byte[] getBytes() {
+		byte[] dataBytes = new byte[DATA_CODE_LEN];
+		dataBytes[0] = 0x00;
+		dataBytes[1] = ByteUtil.combine2bytesToOne(mCrcHigh,mDataHigh);
+		dataBytes[2] = 0x01;
+		dataBytes[3] = mSeqHeader;
+		dataBytes[4] = 0x00;
+		dataBytes[5] = ByteUtil.combine2bytesToOne(mCrcLow, mDataLow);
+		return dataBytes;
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		byte[] dataBytes = getBytes();
+		for (int i = 0; i < DATA_CODE_LEN; i++) {
+			String hexString = ByteUtil.convertByte2HexString(dataBytes[i]);
+			sb.append("0x");
+			if (hexString.length() == 1) {
+				sb.append("0");
+			}
+			sb.append(hexString).append(" ");
+		}
+		return sb.toString();
+	}
+
+	@Override
+	public char[] getU8s() {
+		throw new RuntimeException("DataCode don't support getU8s()");
+	}
+
+}

+package com.xgimi.smartscreen.confignetwork.protocol;
+
+import com.xgimi.smartscreen.confignetwork.task.ICodeData;
+import com.xgimi.smartscreen.confignetwork.util.ByteUtil;
+import com.xgimi.smartscreen.confignetwork.util.CRC8;
+import com.xgimi.smartscreen.confignetwork.util.NetUtil;
+
+import java.net.InetAddress;
+
+
+public class DatumCode implements ICodeData {
+	
+	// define by the Ch protocol, all of the datum code should add 1 at last to prevent 0
+	private static final int EXTRA_LEN = 40;
+	private static final int EXTRA_HEAD_LEN = 5;
+	
+	private final DataCode[] mDataCodes;
+
+	/**
+	 * Constructor of DatumCode
+	 * @param apSsid the Ap's ssid
+	 * @param apBssid the Ap's bssid
+	 * @param apPassword the Ap's password
+	 * @param ipAddress the ip address of the phone or pad
+	 * @param isSsidHiden whether the Ap's ssid is hidden
+	 */
+	public DatumCode(String apSsid, String apBssid, String apPassword, InetAddress ipAddress, boolean isSsidHiden) {
+		// Data = total len(1 byte) + apPwd len(1 byte) + SSID CRC(1 byte) +
+		// BSSID CRC(1 byte) + TOTAL XOR(1 byte)+ ipAddress(4 byte) + apPwd + apSsid apPwdLen <=
+		// 105 at the moment
+
+		// total xor
+		char totalXor = 0;
+
+		char apPwdLen = (char) ByteUtil.getBytesByString(apPassword).length;
+		CRC8 crc = new CRC8();
+		crc.update(ByteUtil.getBytesByString(apSsid));
+		char apSsidCrc = (char) crc.getValue();
+
+		crc.reset();
+		crc.update(NetUtil.parseBssid2bytes(apBssid));
+		char apBssidCrc = (char) crc.getValue();
+
+		char apSsidLen = (char) ByteUtil.getBytesByString(apSsid).length;
+		// hostname parse
+		String ipAddrStrs[] = ipAddress.getHostAddress().split("\\.");
+		int ipLen = ipAddrStrs.length;
+
+		char ipAddrChars[] = new char[ipLen];
+		// only support ipv4 at the moment
+		for (int i = 0; i < ipLen; ++i) {
+			ipAddrChars[i] = (char) Integer.parseInt(ipAddrStrs[i]);
+		}
+
+
+		char _totalLen = (char) (EXTRA_HEAD_LEN + ipLen + apPwdLen + apSsidLen);
+		char totalLen = isSsidHiden ? (char) (EXTRA_HEAD_LEN + ipLen + apPwdLen + apSsidLen)
+				: (char) (EXTRA_HEAD_LEN + ipLen + apPwdLen);
+
+		// build data codes
+		mDataCodes = new DataCode[totalLen];
+		mDataCodes[0] = new DataCode(_totalLen, 0);
+		totalXor ^= _totalLen;
+		mDataCodes[1] = new DataCode(apPwdLen, 1);
+		totalXor ^= apPwdLen;
+		mDataCodes[2] = new DataCode(apSsidCrc, 2);
+		totalXor ^= apSsidCrc;
+		mDataCodes[3] = new DataCode(apBssidCrc, 3);
+		totalXor ^= apBssidCrc;
+		mDataCodes[4] = null;
+		for (int i = 0; i < ipLen; ++i) {
+			mDataCodes[i + EXTRA_HEAD_LEN] = new DataCode(ipAddrChars[i], i + EXTRA_HEAD_LEN);
+			totalXor ^= ipAddrChars[i];
+		}
+
+		byte[] apPwdBytes = ByteUtil.getBytesByString(apPassword);
+		char[] apPwdChars = new char[apPwdBytes.length];
+		for (int i = 0;i < apPwdBytes.length; i++) {
+			apPwdChars[i] = ByteUtil.convertByte2Uint8(apPwdBytes[i]);
+		}
+		for (int i = 0; i < apPwdChars.length; i++) {
+			mDataCodes[i + EXTRA_HEAD_LEN + ipLen] = new DataCode(
+					apPwdChars[i], i + EXTRA_HEAD_LEN + ipLen);
+			totalXor ^= apPwdChars[i];
+		}
+
+		byte[] apSsidBytes = ByteUtil.getBytesByString(apSsid);
+		char[] apSsidChars = new char[apSsidBytes.length];
+
+		// totalXor will xor apSsidChars no matter whether the ssid is hidden
+		for (int i = 0; i < apSsidBytes.length; i++) {
+			apSsidChars[i] = ByteUtil.convertByte2Uint8(apSsidBytes[i]);
+			totalXor ^= apSsidChars[i];
+		}
+
+		if (isSsidHiden) {
+			for (int i = 0; i < apSsidChars.length; i++) {
+				mDataCodes[i + EXTRA_HEAD_LEN + ipLen + apPwdLen] = new DataCode(
+						apSsidChars[i], i + EXTRA_HEAD_LEN + ipLen + apPwdLen);
+			}
+		}
+
+		// set total xor last
+		mDataCodes[4] = new DataCode(totalXor, 4);
+	}
+
+	@Override
+	public byte[] getBytes() {
+		byte[] datumCode = new byte[mDataCodes.length * DataCode.DATA_CODE_LEN];
+		for (int i = 0; i < mDataCodes.length; i++) {
+			System.arraycopy(mDataCodes[i].getBytes(), 0, datumCode, i
+					* DataCode.DATA_CODE_LEN, DataCode.DATA_CODE_LEN);
+		}
+		return datumCode;
+	}
+	
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		byte[] dataBytes = getBytes();
+		for (int i = 0; i < dataBytes.length; i++) {
+			String hexString = ByteUtil.convertByte2HexString(dataBytes[i]);
+			sb.append("0x");
+			if (hexString.length() == 1) {
+				sb.append("0");
+			}
+			sb.append(hexString).append(" ");
+		}
+		return sb.toString();
+	}
+	
+	@Override
+	public char[] getU8s() {
+		byte[] dataBytes = getBytes();
+		int len = dataBytes.length / 2;
+		char[] dataU8s = new char[len];
+		byte high, low;
+		for (int i = 0; i < len; i++) {
+			high = dataBytes[i * 2];
+			low = dataBytes[i * 2 + 1];
+			dataU8s[i] = (char) (ByteUtil.combine2bytesToU16(high, low) + EXTRA_LEN);
+		}
+		return dataU8s;
+	}
+}

+package com.xgimi.smartscreen.confignetwork.protocol;
+
+
+import com.xgimi.smartscreen.confignetwork.task.ICodeData;
+import com.xgimi.smartscreen.confignetwork.util.ByteUtil;
+
+public class GuideCode implements ICodeData {
+
+	public static final int GUIDE_CODE_LEN = 4;
+
+	@Override
+	public byte[] getBytes() {
+		throw new RuntimeException("DataCode don't support getBytes()");
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		char[] dataU8s = getU8s();
+		for (int i = 0; i < GUIDE_CODE_LEN; i++) {
+			String hexString = ByteUtil.convertU8ToHexString(dataU8s[i]);
+			sb.append("0x");
+			if (hexString.length() == 1) {
+				sb.append("0");
+			}
+			sb.append(hexString).append(" ");
+		}
+		return sb.toString();
+	}
+
+	@Override
+	public char[] getU8s() {
+		char[] guidesU8s = new char[GUIDE_CODE_LEN];
+		guidesU8s[0] = 515;
+		guidesU8s[1] = 514;
+		guidesU8s[2] = 513;
+		guidesU8s[3] = 512;
+		return guidesU8s;
+	}
+}

+package com.xgimi.smartscreen.confignetwork.task;
+
+public class ChTaskParameter implements IChTaskParameter {
+
+	private long mIntervalGuideCodeMillisecond;
+	private long mIntervalDataCodeMillisecond;
+	private long mTimeoutGuideCodeMillisecond;
+	private long mTimeoutDataCodeMillisecond;
+	private int mTotalRepeatTime;
+	private int mChResultOneLen;
+	private int mChResultMacLen;
+	private int mChResultIpLen;
+	private int mChResultTotalLen;
+	private int mPortListening;
+	private int mTargetPort;
+	private int mWaitUdpReceivingMilliseond;
+	private int mWaitUdpSendingMillisecond;
+	private int mThresholdSucBroadcastCount;
+	private int mExpectTaskResultCount;
+	private static int _datagramCount = 0;
+
+	public ChTaskParameter() {
+		mIntervalGuideCodeMillisecond = 10;
+		mIntervalDataCodeMillisecond = 10;
+		mTimeoutGuideCodeMillisecond = 2000;
+		mTimeoutDataCodeMillisecond = 4000;
+		mTotalRepeatTime = 1;
+		mChResultOneLen = 1;
+		mChResultMacLen = 6;
+		mChResultIpLen = 4;
+		mChResultTotalLen = 1 + 6 + 4;
+		mPortListening = 18266;
+		mTargetPort = 7001;
+		mWaitUdpReceivingMilliseond = 15000;
+		mWaitUdpSendingMillisecond = 45000;
+		mThresholdSucBroadcastCount = 1;
+		mExpectTaskResultCount = 1;
+	}
+
+	// the range of the result should be 1-100
+	private static int __getNextDatagramCount() {
+		return 1 + (_datagramCount++) % 100;
+	}
+
+	@Override
+	public long getIntervalGuideCodeMillisecond() {
+		return mIntervalGuideCodeMillisecond;
+	}
+
+	@Override
+	public long getIntervalDataCodeMillisecond() {
+		return mIntervalDataCodeMillisecond;
+	}
+
+	@Override
+	public long getTimeoutGuideCodeMillisecond() {
+		return mTimeoutGuideCodeMillisecond;
+	}
+
+	@Override
+	public long getTimeoutDataCodeMillisecond() {
+		return mTimeoutDataCodeMillisecond;
+	}
+
+	@Override
+	public long getTimeoutTotalCodeMillisecond() {
+		return mTimeoutGuideCodeMillisecond + mTimeoutDataCodeMillisecond;
+	}
+
+	@Override
+	public int getTotalRepeatTime() {
+		return mTotalRepeatTime;
+	}
+
+	@Override
+	public int getChResultOneLen() {
+		return mChResultOneLen;
+	}
+
+	@Override
+	public int getChResultMacLen() {
+		return mChResultMacLen;
+	}
+
+	@Override
+	public int getChResultIpLen() {
+		return mChResultIpLen;
+	}
+
+	@Override
+	public int getChResultTotalLen() {
+		return mChResultTotalLen;
+	}
+
+	@Override
+	public int getPortListening() {
+		return mPortListening;
+	}
+
+	// target hostname is : 234.1.1.1, 234.2.2.2, 234.3.3.3 to 234.100.100.100
+	@Override
+	public String getTargetHostname() {
+		int count = __getNextDatagramCount();
+		return "234." + count + "." + count + "." + count;
+	}
+
+	@Override
+	public int getTargetPort() {
+		return mTargetPort;
+	}
+
+	@Override
+	public int getWaitUdpReceivingMillisecond() {
+		return mWaitUdpReceivingMilliseond;
+	}
+
+	@Override
+	public int getWaitUdpSendingMillisecond() {
+		return mWaitUdpSendingMillisecond;
+	}
+
+	@Override
+	public int getWaitUdpTotalMillisecond() {
+		return mWaitUdpReceivingMilliseond + mWaitUdpSendingMillisecond;
+	}
+
+	@Override
+	public int getThresholdSucBroadcastCount() {
+		return mThresholdSucBroadcastCount;
+	}
+
+	@Override
+	public void setWaitUdpTotalMillisecond(int waitUdpTotalMillisecond) {
+		if (waitUdpTotalMillisecond < mWaitUdpReceivingMilliseond
+				+ getTimeoutTotalCodeMillisecond()) {
+			// if it happen, even one turn about sending udp broadcast can't be
+			// completed
+			throw new IllegalArgumentException(
+					"waitUdpTotalMillisecod is invalid, "
+							+ "it is less than mWaitUdpReceivingMilliseond + getTimeoutTotalCodeMillisecond()");
+		}
+		mWaitUdpSendingMillisecond = waitUdpTotalMillisecond
+				- mWaitUdpReceivingMilliseond;
+	}
+
+	@Override
+	public int getExpectTaskResultCount() {
+		return this.mExpectTaskResultCount;
+	}
+
+	@Override
+	public void setExpectTaskResultCount(int expectTaskResultCount) {
+		this.mExpectTaskResultCount = expectTaskResultCount;
+	}
+
+}

+package com.xgimi.smartscreen.confignetwork.task;
+
+public interface IChGenerator {
+	/**
+	 * Get guide code by the format of byte[][]
+	 * 
+	 * @return guide code by the format of byte[][]
+	 */
+	byte[][] getGCBytes2();
+
+	/**
+	 * Get data code by the format of byte[][]
+	 * 
+	 * @return data code by the format of byte[][]
+	 */
+	byte[][] getDCBytes2();
+}

+package com.xgimi.smartscreen.confignetwork.task;
+
+public interface IChTaskParameter {
+	
+	/**
+	 * get interval millisecond for guide code(the time between each guide code sending)
+	 * @return interval millisecond for guide code(the time between each guide code sending)
+	 */
+	long getIntervalGuideCodeMillisecond();
+	
+	/**
+	 * get interval millisecond for data code(the time between each data code sending)
+	 * @return interval millisecond for data code(the time between each data code sending)
+	 */
+	long getIntervalDataCodeMillisecond();
+
+	/**
+	 * get timeout millisecond for guide code(the time how much the guide code sending)
+	 * @return timeout millisecond for guide code(the time how much the guide code sending)
+	 */
+	long getTimeoutGuideCodeMillisecond();
+	
+	/**
+	 * get timeout millisecond for data code(the time how much the data code sending)
+	 * @return timeout millisecond for data code(the time how much the data code sending)
+	 */
+	long getTimeoutDataCodeMillisecond();
+	
+	/**
+	 * get timeout millisecond for total code(guide code and data code altogether)
+	 * @return timeout millisecond for total code(guide code and data code altogether)
+	 */
+	long getTimeoutTotalCodeMillisecond();
+
+	/**
+	 * get total repeat time for executing ch task
+	 * @return total repeat time for executing ch task
+	 */
+	int getTotalRepeatTime();
+	
+	/**
+	 * the length of the Ch result 1st byte is the total length of ssid and
+	 * password, the other 6 bytes are the device's bssid
+	 */
+	
+	/**
+	 * get chResult length of one
+	 * @return length of one
+	 */
+	int getChResultOneLen();
+	
+	/**
+	 * get chResult length of mac
+	 * @return length of mac
+	 */
+	int getChResultMacLen();
+	
+	/**
+	 * get chResult length of ip
+	 * @return length of ip
+	 */
+	int getChResultIpLen();
+	
+	/**
+	 * get chResult total length
+	 * @return total length
+	 */
+	int getChResultTotalLen();
+	
+	/**
+	 * get port for listening(used by server)
+	 * @return port for listening(used by server)
+	 */
+	int getPortListening();
+	
+	/**
+	 * get target hostname
+	 * @return target hostame(used by client)
+	 */
+	String getTargetHostname();
+	
+	/**
+	 * get target port
+	 * @return target port(used by client)
+	 */
+	int getTargetPort();
+	
+	/**
+	 * get millisecond for waiting udp receiving(receiving without sending)
+	 * @return millisecond for waiting udp receiving(receiving without sending)
+	 */
+	int getWaitUdpReceivingMillisecond();
+	
+	/**
+	 * get millisecond for waiting udp sending(sending including receiving)
+	 * @return millisecond for waiting udep sending(sending including receiving)
+	 */
+	int getWaitUdpSendingMillisecond();
+	
+	/**
+	 * get millisecond for waiting udp sending and receiving 
+	 * @return millisecond for waiting udp sending and receiving
+	 */
+	int getWaitUdpTotalMillisecond();
+	
+	/**
+	 * get the threshold for how many correct broadcast should be received
+	 * @return the threshold for how many correct broadcast should be received
+	 */
+	int getThresholdSucBroadcastCount();
+	
+	/**
+	 * set the millisecond for waiting udp sending and receiving
+	 * @param waitUdpTotalMillisecond the millisecond for waiting udp sending and receiving
+	 */
+	void setWaitUdpTotalMillisecond(int waitUdpTotalMillisecond);
+	
+	/**
+	 * get the count of expect task results
+	 * @return the count of expect task results
+	 */
+	int getExpectTaskResultCount();
+	
+	/**
+	 * set the count of expect task results
+	 * @param expectTaskResultCount the count of expect task results
+	 */
+	void setExpectTaskResultCount(int expectTaskResultCount);
+}

+package com.xgimi.smartscreen.confignetwork.task;
+
+/**
+ * the class used to represent some code to be transformed by UDP socket should implement the interface
+ * @author afunx
+ *
+ */
+public interface ICodeData {
+	/**
+	 * Get the byte[] to be transformed.
+	 * 
+	 * 
+	 * @return the byte[] to be transfromed
+	 */
+	byte[] getBytes();
+
+	/**
+	 * Get the char[](u8[]) to be transfromed.
+	 * 
+	 * @return the char[](u8) to be transformed
+	 */
+	char[] getU8s();
+}

+package com.xgimi.smartscreen.confignetwork.task;
+
+import android.content.Context;
+import android.os.Looper;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.xgimi.smartscreen.confignetwork.ChResult;
+import com.xgimi.smartscreen.confignetwork.IChListener;
+import com.xgimi.smartscreen.confignetwork.IChResult;
+import com.xgimi.smartscreen.confignetwork.protocol.ChGenerator;
+import com.xgimi.smartscreen.confignetwork.udp.UDPSocketClient;
+import com.xgimi.smartscreen.confignetwork.udp.UDPSocketServer;
+import com.xgimi.smartscreen.confignetwork.util.ByteUtil;
+import com.xgimi.smartscreen.confignetwork.util.NetUtil;
+
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class __ChTask implements __IChTask {
+
+	/**
+	 * one indivisible data contain 3 9bits info
+	 */
+	private static final int ONE_DATA_LEN = 3;
+
+	private static final String TAG = "ChTask";
+
+	private volatile List<IChResult> mChResultList;
+	private volatile boolean mIsSuc = false;
+	private volatile boolean mIsInterrupt = false;
+	private volatile boolean mIsExecuted = false;
+	private final UDPSocketClient mSocketClient;
+	private final UDPSocketServer mSocketServer;
+	private final String mApSsid;
+	private final String mApBssid;
+	private final boolean mIsSsidHidden;
+	private final String mApPassword;
+	private final Context mContext;
+	private AtomicBoolean mIsCancelled;
+	private IChTaskParameter mParameter;
+	private volatile Map<String, Integer> mBssidTaskSucCountMap;
+	private IChListener mChListener;
+
+	public __ChTask(String apSsid, String apBssid, String apPassword,
+					Context context, IChTaskParameter parameter,
+					boolean isSsidHidden) {
+		if (TextUtils.isEmpty(apSsid)) {
+			throw new IllegalArgumentException("the apSsid should be null or empty");
+		}
+		if (apPassword == null) {
+			apPassword = "";
+		}
+		mContext = context;
+		mApSsid = apSsid;
+		mApBssid = apBssid;
+		mApPassword = apPassword;
+		mIsCancelled = new AtomicBoolean(false);
+		mSocketClient = new UDPSocketClient();
+		mParameter = parameter;
+		mSocketServer = new UDPSocketServer(mParameter.getPortListening(),
+				mParameter.getWaitUdpTotalMillisecond(), context);
+		mIsSsidHidden = isSsidHidden;
+		mChResultList = new ArrayList<IChResult>();
+		mBssidTaskSucCountMap = new HashMap<String, Integer>();
+	}
+
+	private void __putChResult(boolean isSuc, String bssid, InetAddress inetAddress) {
+		synchronized (mChResultList) {
+			// check whether the result receive enough UDP response
+			boolean isTaskSucCountEnough = false;
+			Integer count = mBssidTaskSucCountMap.get(bssid);
+			if (count == null) {
+				count = 0;
+			}
+			++count;
+			if (__IChTask.DEBUG) {
+				Log.d(TAG, "__putChResult(): count = " + count);
+			}
+			mBssidTaskSucCountMap.put(bssid, count);
+			isTaskSucCountEnough = count >= mParameter
+					.getThresholdSucBroadcastCount();
+			if (!isTaskSucCountEnough) {
+				if (__IChTask.DEBUG) {
+					Log.d(TAG, "__putChResult(): count = " + count + ", isn't enough");
+				}
+				return;
+			}
+			// check whether the result is in the mChResultList already
+			boolean isExist = false;
+			for (IChResult chResultInList : mChResultList) {
+				if (chResultInList.getBssid().equals(bssid)) {
+					isExist = true;
+					break;
+				}
+			}
+			// only add the result who isn't in the mChResultList
+			if (!isExist) {
+				if (__IChTask.DEBUG) {
+					Log.d(TAG, "__putChResult(): put one more result");
+				}
+				final IChResult chResult = new ChResult(isSuc, bssid, inetAddress);
+				mChResultList.add(chResult);
+				if (mChListener != null) {
+					mChListener.onChResultAdded(chResult);
+				}
+			}
+		}
+	}
+
+	private List<IChResult> __getChResultList() {
+		synchronized (mChResultList) {
+			if (mChResultList.isEmpty()) {
+				ChResult chResultFail = new ChResult(false, null, null);
+				chResultFail.setIsCancelled(mIsCancelled.get());
+				mChResultList.add(chResultFail);
+			}
+
+			return mChResultList;
+		}
+	}
+
+	private synchronized void __interrupt() {
+		if (!mIsInterrupt) {
+			mIsInterrupt = true;
+			mSocketClient.interrupt();
+			mSocketServer.interrupt();
+			// interrupt the current Thread which is used to wait for udp response
+			Thread.currentThread().interrupt();
+		}
+	}
+
+	@Override
+	public void interrupt() {
+		if (__IChTask.DEBUG) {
+			Log.d(TAG, "interrupt()");
+		}
+		mIsCancelled.set(true);
+		__interrupt();
+	}
+
+	private void __listenAsyn(final int expectDataLen) {
+		new Thread() {
+			public void run() {
+				if (__IChTask.DEBUG) {
+					Log.d(TAG, "__listenAsyn() start");
+				}
+				long startTimestamp = System.currentTimeMillis();
+				byte[] apSsidAndPassword = ByteUtil.getBytesByString(mApSsid + mApPassword);
+				byte expectOneByte = (byte) (apSsidAndPassword.length + 9);
+				if (__IChTask.DEBUG) {
+					Log.i(TAG, "expectOneByte: " + (0 + expectOneByte));
+				}
+				byte receiveOneByte = -1;
+				byte[] receiveBytes = null;
+				while (mChResultList.size() < mParameter.getExpectTaskResultCount() && !mIsInterrupt) {
+					receiveBytes = mSocketServer.receiveSpecLenBytes(expectDataLen);
+					if (receiveBytes != null) {
+						receiveOneByte = receiveBytes[0];
+					} else {
+						receiveOneByte = -1;
+					}
+					if (receiveOneByte == expectOneByte) {
+						if (__IChTask.DEBUG) {
+							Log.i(TAG, "receive correct broadcast");
+						}
+						// change the socket's timeout
+						long consume = System.currentTimeMillis() - startTimestamp;
+						int timeout = (int) (mParameter.getWaitUdpTotalMillisecond() - consume);
+						if (timeout < 0) {
+							if (__IChTask.DEBUG) {
+								Log.i(TAG, "ch timeout");
+							}
+							break;
+						} else {
+							if (__IChTask.DEBUG) {
+								Log.i(TAG, "mSocketServer's new timeout is " + timeout + " milliseconds");
+							}
+							mSocketServer.setSoTimeout(timeout);
+							if (__IChTask.DEBUG) {
+								Log.i(TAG, "receive correct broadcast");
+							}
+							if (receiveBytes != null) {
+								String bssid = ByteUtil.parseBssid(
+										receiveBytes,
+										mParameter.getChResultOneLen(),
+										mParameter.getChResultMacLen());
+								InetAddress inetAddress = NetUtil.parseInetAddr(
+												receiveBytes,
+												mParameter.getChResultOneLen() + mParameter.getChResultMacLen(),
+												mParameter.getChResultIpLen());
+								__putChResult(true, bssid, inetAddress);
+							}
+						}
+					} else {
+						if (__IChTask.DEBUG) {
+							Log.i(TAG, "receive rubbish message, just ignore");
+						}
+					}
+				}
+				mIsSuc = mChResultList.size() >= mParameter.getExpectTaskResultCount();
+				__ChTask.this.__interrupt();
+				if (__IChTask.DEBUG) {
+					Log.d(TAG, "__listenAsyn() finish");
+				}
+			}
+		}.start();
+	}
+
+	private boolean __execute(IChGenerator generator) {
+
+		long startTime = System.currentTimeMillis();
+		long currentTime = startTime;
+		long lastTime = currentTime - mParameter.getTimeoutTotalCodeMillisecond();
+
+		byte[][] gcBytes2 = generator.getGCBytes2();
+		byte[][] dcBytes2 = generator.getDCBytes2();
+
+		int index = 0;
+		while (!mIsInterrupt) {
+			if (currentTime - lastTime >= mParameter.getTimeoutTotalCodeMillisecond()) {
+				if (__IChTask.DEBUG) {
+					Log.d(TAG, "send gc code ");
+				}
+				// send guide code
+				while (!mIsInterrupt && System.currentTimeMillis() - currentTime < mParameter.getTimeoutGuideCodeMillisecond()) {
+					mSocketClient.sendData(gcBytes2,
+							mParameter.getTargetHostname(),
+							mParameter.getTargetPort(),
+							mParameter.getIntervalGuideCodeMillisecond());
+					// check whether the udp is send enough time
+					if (System.currentTimeMillis() - startTime > mParameter.getWaitUdpSendingMillisecond()) {
+						break;
+					}
+				}
+				lastTime = currentTime;
+			} else {
+				mSocketClient.sendData(dcBytes2, index, ONE_DATA_LEN,
+						mParameter.getTargetHostname(),
+						mParameter.getTargetPort(),
+						mParameter.getIntervalDataCodeMillisecond());
+				index = (index + ONE_DATA_LEN) % dcBytes2.length;
+			}
+			currentTime = System.currentTimeMillis();
+			// check whether the udp is send enough time
+			if (currentTime - startTime > mParameter.getWaitUdpSendingMillisecond()) {
+				break;
+			}
+		}
+
+		return mIsSuc;
+	}
+
+	private void __checkTaskValid() {
+		// !!!NOTE: the ch task could be executed only once
+		if (this.mIsExecuted) {
+			throw new IllegalStateException("the Ch task could be executed only once");
+		}
+		this.mIsExecuted = true;
+	}
+
+	@Override
+	public IChResult executeForResult() throws RuntimeException {
+		return executeForResults(1).get(0);
+	}
+
+	@Override
+	public boolean isCancelled() {
+		return this.mIsCancelled.get();
+	}
+
+	@Override
+	public List<IChResult> executeForResults(int expectTaskResultCount)
+			throws RuntimeException {
+		__checkTaskValid();
+
+		mParameter.setExpectTaskResultCount(expectTaskResultCount);
+
+		if (__IChTask.DEBUG) {
+			Log.d(TAG, "execute()");
+		}
+		if (Looper.myLooper() == Looper.getMainLooper()) {
+			throw new RuntimeException(
+					"Don't call the ch Task at Main(UI) thread directly.");
+		}
+		InetAddress localInetAddress = NetUtil.getLocalInetAddress(mContext);
+		if (__IChTask.DEBUG) {
+			Log.i(TAG, "localInetAddress: " + localInetAddress);
+		}
+		// generator the ch byte[][] to be transformed, which will cost
+		// some time(maybe a bit much)
+		IChGenerator generator = new ChGenerator(mApSsid, mApBssid,
+				mApPassword, localInetAddress, mIsSsidHidden);
+		// listen the ch result asyn
+		__listenAsyn(mParameter.getChResultTotalLen());
+		boolean isSuc = false;
+		for (int i = 0; i < mParameter.getTotalRepeatTime(); i++) {
+			isSuc = __execute(generator);
+			if (isSuc) {
+				return __getChResultList();
+			}
+		}
+
+		if (!mIsInterrupt) {
+			// wait the udp response without sending udp broadcast
+			try {
+				Thread.sleep(mParameter.getWaitUdpReceivingMillisecond());
+			} catch (InterruptedException e) {
+				// receive the udp broadcast or the user interrupt the task
+				if (this.mIsSuc) {
+					return __getChResultList();
+				} else {
+					this.__interrupt();
+					return __getChResultList();
+				}
+			}
+			this.__interrupt();
+		}
+		
+		return __getChResultList();
+	}
+
+	@Override
+	public void setChListener(IChListener chListener) {
+		mChListener = chListener;
+	}
+
+}

+package com.xgimi.smartscreen.confignetwork.task;
+
+import com.xgimi.smartscreen.confignetwork.IChListener;
+import com.xgimi.smartscreen.confignetwork.IChResult;
+
+import java.util.List;
+
+
+/**
+ * IChTask defined the task of ch should offer. INTERVAL here means
+ * the milliseconds of interval of the step. REPEAT here means the repeat times
+ * of the step.
+ * 
+ * @author afunx
+ * 
+ */
+public interface __IChTask {
+
+	/**
+	 * set the ch listener, when one device is connected to the Ap, it will be called back
+	 * @param chListener when one device is connected to the Ap, it will be called back
+	 */
+	void setChListener(IChListener chListener);
+	
+	/**
+	 * Interrupt the Ch Task when User tap back or close the Application.
+	 */
+	void interrupt();
+
+	/**
+	 * Note: !!!Don't call the task at UI Main Thread or RuntimeException will
+	 * be thrown Execute the Ch Task and return the result
+	 * 
+	 * @return the IChResult
+	 * @throws RuntimeException
+	 */
+	IChResult executeForResult() throws RuntimeException;
+
+	/**
+	 * Note: !!!Don't call the task at UI Main Thread or RuntimeException will
+	 * be thrown Execute the Ch Task and return the result
+	 * 
+	 * @param expectTaskResultCount
+	 *            the expect result count(if expectTaskResultCount <= 0,
+	 *            expectTaskResultCount = Integer.MAX_VALUE)
+	 * @return the list of IChResult
+	 * @throws RuntimeException
+	 */
+	List<IChResult> executeForResults(int expectTaskResultCount) throws RuntimeException;
+	
+	/**
+	 * Turn on or off the log.
+	 */
+	static final boolean DEBUG = true;
+
+	boolean isCancelled();
+}

+package com.xgimi.smartscreen.confignetwork.udp;
+
+import android.util.Log;
+
+import com.xgimi.smartscreen.confignetwork.task.__IChTask;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+
+/**
+ * this class is used to help send UDP data according to length
+ *
+ * @author afunx
+ */
+public class UDPSocketClient {
+
+    private static final String TAG = "UDPSocketClient";
+    private DatagramSocket mSocket;
+    private volatile boolean mIsStop;
+    private volatile boolean mIsClosed;
+
+    public UDPSocketClient() {
+        try {
+            this.mSocket = new DatagramSocket();
+            this.mIsStop = false;
+            this.mIsClosed = false;
+        } catch (SocketException e) {
+            if (__IChTask.DEBUG) {
+                Log.e(TAG, "SocketException");
+            }
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        close();
+        super.finalize();
+    }
+
+    public void interrupt() {
+        if (__IChTask.DEBUG) {
+            Log.i(TAG, "USPSocketClient is interrupt");
+        }
+        this.mIsStop = true;
+    }
+
+    /**
+     * close the UDP socket
+     */
+    public synchronized void close() {
+        if (!this.mIsClosed) {
+            this.mSocket.close();
+            this.mIsClosed = true;
+        }
+    }
+
+    /**
+     * send the data by UDP
+     *
+     * @param data       the data to be sent
+     * @param targetHostName the host name of target, e.g. 192.168.1.101
+     * @param targetPort the port of target
+     * @param interval   the milliseconds to between each UDP sent
+     */
+    public void sendData(byte[][] data, String targetHostName, int targetPort, long interval) {
+        sendData(data, 0, data.length, targetHostName, targetPort, interval);
+    }
+
+
+    /**
+     * send the data by UDP
+     *
+     * @param data       the data to be sent
+     * @param offset     the offset which data to be sent
+     * @param count      the count of the data
+     * @param targetHostName the host name of target, e.g. 192.168.1.101
+     * @param targetPort the port of target
+     * @param interval   the milliseconds to between each UDP sent
+     */
+    public void sendData(byte[][] data, int offset, int count, String targetHostName, int targetPort, long interval) {
+        if ((data == null) || (data.length <= 0)) {
+            if (__IChTask.DEBUG) {
+                Log.e(TAG, "sendData(): data == null or length <= 0");
+            }
+            return;
+        }
+        for (int i = offset; !mIsStop && i < offset + count; i++) {
+            if (data[i].length == 0) {
+                continue;
+            }
+            try {
+                // Log.i(TAG, "data[" + i + " +].length = " + data[i].length);
+                DatagramPacket localDatagramPacket = new DatagramPacket(
+                        data[i], data[i].length,
+                        InetAddress.getByName(targetHostName), targetPort);
+                this.mSocket.send(localDatagramPacket);
+            } catch (UnknownHostException e) {
+                if (__IChTask.DEBUG) {
+                    Log.e(TAG, "sendData(): UnknownHostException");
+                }
+                e.printStackTrace();
+                mIsStop = true;
+                break;
+            } catch (IOException e) {
+                if (__IChTask.DEBUG) {
+                    Log.e(TAG, "sendData(): IOException, but just ignore it");
+                }
+                // for the Ap will make some troubles when the phone send too many UDP packets,
+                // but we don't expect the UDP packet received by others, so just ignore it
+            }
+            try {
+                Thread.sleep(interval);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+                if (__IChTask.DEBUG) {
+                    Log.e(TAG, "sendData is Interrupted");
+                }
+                mIsStop = true;
+                break;
+            }
+        }
+        if (mIsStop) {
+            close();
+        }
+    }
+}

+package com.xgimi.smartscreen.confignetwork.udp;
+
+import android.content.Context;
+import android.net.wifi.WifiManager;
+import android.util.Log;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.SocketException;
+import java.util.Arrays;
+
+public class UDPSocketServer {
+
+    private static final String TAG = "UDPSocketServer";
+    private DatagramPacket mReceivePacket;
+    private DatagramSocket mServerSocket;
+    private Context mContext;
+    private WifiManager.MulticastLock mLock;
+    private final byte[] buffer;
+    private volatile boolean mIsClosed;
+
+    private synchronized void acquireLock() {
+        if (mLock != null && !mLock.isHeld()) {
+            mLock.acquire();
+        }
+    }
+
+    private synchronized void releaseLock() {
+        if (mLock != null && mLock.isHeld()) {
+            try {
+                mLock.release();
+            } catch (Throwable th) {
+                // ignoring this exception, probably wakeLock was already released
+            }
+        }
+    }
+
+    /**
+     * Constructor of UDP Socket Server
+     *
+     * @param port          the Socket Server port
+     * @param socketTimeout the socket read timeout
+     * @param context       the context of the Application
+     */
+    public UDPSocketServer(int port, int socketTimeout, Context context) {
+        this.mContext = context;
+        this.buffer = new byte[64];
+        this.mReceivePacket = new DatagramPacket(buffer, 64);
+        try {
+            this.mServerSocket = new DatagramSocket(port);
+            this.mServerSocket.setSoTimeout(socketTimeout);
+            this.mIsClosed = false;
+            WifiManager manager = (WifiManager) mContext
+                    .getSystemService(Context.WIFI_SERVICE);
+            mLock = manager.createMulticastLock("test wifi");
+            Log.d(TAG, "mServerSocket is created, socket read timeout: "
+                    + socketTimeout + ", port: " + port);
+        } catch (IOException e) {
+            Log.e(TAG, "IOException");
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Set the socket timeout in milliseconds
+     *
+     * @param timeout the timeout in milliseconds or 0 for no timeout.
+     * @return true whether the timeout is set suc
+     */
+    public boolean setSoTimeout(int timeout) {
+        try {
+            this.mServerSocket.setSoTimeout(timeout);
+            return true;
+        } catch (SocketException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    /**
+     * Receive one byte from the port and convert it into String
+     *
+     * @return
+     */
+    public byte receiveOneByte() {
+        Log.d(TAG, "receiveOneByte() entrance");
+        try {
+            acquireLock();
+            mServerSocket.receive(mReceivePacket);
+            Log.d(TAG, "receive: " + (0 + mReceivePacket.getData()[0]));
+            return mReceivePacket.getData()[0];
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return Byte.MIN_VALUE;
+    }
+
+    /**
+     * Receive specific length bytes from the port and convert it into String
+     * 21,24,-2,52,-102,-93,-60
+     * 15,18,fe,34,9a,a3,c4
+     *
+     * @return
+     */
+    public byte[] receiveSpecLenBytes(int len) {
+        Log.d(TAG, "receiveSpecLenBytes() entrance: len = " + len);
+        try {
+            acquireLock();
+            mServerSocket.receive(mReceivePacket);
+            byte[] recDatas = Arrays.copyOf(mReceivePacket.getData(), mReceivePacket.getLength());
+            Log.d(TAG, "received len : " + recDatas.length);
+            for (int i = 0; i < recDatas.length; i++) {
+                Log.e(TAG, "recDatas[" + i + "]:" + recDatas[i]);
+            }
+            Log.e(TAG, "receiveSpecLenBytes: " + new String(recDatas));
+            if (recDatas.length != len) {
+                Log.w(TAG,
+                        "received len is different from specific len, return null");
+                return null;
+            }
+            return recDatas;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public void interrupt() {
+        Log.i(TAG, "USPSocketServer is interrupt");
+        close();
+    }
+
+    public synchronized void close() {
+        if (!this.mIsClosed) {
+            Log.e(TAG, "mServerSocket is closed");
+            mServerSocket.close();
+            releaseLock();
+            this.mIsClosed = true;
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        close();
+        super.finalize();
+    }
+
+}

+package com.xgimi.smartscreen.confignetwork.util;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Random;
+
+/**
+ * In Java, it don't support unsigned int, so we use char to replace uint8.
+ * The range of byte is [-128,127], and the range of char is [0,65535].
+ * So the byte could used to store the uint8.
+ * (We assume that the String could be mapped to assic)
+ *
+ * @author afunx
+ */
+public class ByteUtil {
+
+    public static final String ESPTOUCH_ENCODING_CHARSET = "UTF-8";
+
+    /**
+     * Put String to byte[]
+     *
+     * @param destbytes  the byte[] of dest
+     * @param srcString  the String of src
+     * @param destOffset the offset of byte[]
+     * @param srcOffset  the offset of String
+     * @param count      the count of dest, and the count of src as well
+     */
+    public static void putString2bytes(byte[] destbytes, String srcString,
+                                       int destOffset, int srcOffset, int count) {
+        for (int i = 0; i < count; i++) {
+            destbytes[count + i] = srcString.getBytes()[i];
+        }
+    }
+
+    /**
+     * Convert uint8 into char( we treat char as uint8)
+     *
+     * @param uint8 the unit8 to be converted
+     * @return the byte of the unint8
+     */
+    public static byte convertUint8toByte(char uint8) {
+        if (uint8 > Byte.MAX_VALUE - Byte.MIN_VALUE) {
+            throw new RuntimeException("Out of Boundary");
+        }
+        return (byte) uint8;
+    }
+
+    /**
+     * Convert char into uint8( we treat char as uint8 )
+     *
+     * @param b the byte to be converted
+     * @return the char(uint8)
+     */
+    public static char convertByte2Uint8(byte b) {
+        // char will be promoted to int for char don't support & operator
+        // & 0xff could make negatvie value to positive
+        return (char) (b & 0xff);
+    }
+
+    /**
+     * Convert byte[] into char[]( we treat char[] as uint8[])
+     *
+     * @param bytes the byte[] to be converted
+     * @return the char[](uint8[])
+     */
+    public static char[] convertBytes2Uint8s(byte[] bytes) {
+        int len = bytes.length;
+        char[] uint8s = new char[len];
+        for (int i = 0; i < len; i++) {
+            uint8s[i] = convertByte2Uint8(bytes[i]);
+        }
+        return uint8s;
+    }
+
+    /**
+     * Put byte[] into char[]( we treat char[] as uint8[])
+     *
+     * @param destUint8s       the char[](uint8[]) array
+     * @param srcBytes        the byte[]
+     * @param destOffset the offset of char[](uint8[])
+     * @param srcOffset  the offset of byte[]
+     * @param count      the count of dest, and the count of src as well
+     */
+    public static void putbytes2Uint8s(char[] destUint8s, byte[] srcBytes, int destOffset, int srcOffset, int count) {
+        for (int i = 0; i < count; i++) {
+            destUint8s[destOffset + i] = convertByte2Uint8(srcBytes[srcOffset + i]);
+        }
+    }
+
+    /**
+     * Convert byte to Hex String
+     *
+     * @param b the byte to be converted
+     * @return the Hex String
+     */
+    public static String convertByte2HexString(byte b) {
+        char u8 = convertByte2Uint8(b);
+        return Integer.toHexString(u8);
+    }
+
+    /**
+     * Convert char(uint8) to Hex String
+     *
+     * @param u8 the char(uint8) to be converted
+     * @return the Hex String
+     */
+    public static String convertU8ToHexString(char u8) {
+        return Integer.toHexString(u8);
+    }
+
+    /**
+     * Split uint8 to 2 bytes of high byte and low byte. e.g. 20 = 0x14 should
+     * be split to [0x01,0x04] 0x01 is high byte and 0x04 is low byte
+     *
+     * @param uint8 the char(uint8)
+     * @return the high and low bytes be split, byte[0] is high and byte[1] is
+     * low
+     */
+    public static byte[] splitUint8To2bytes(char uint8) {
+        if (uint8 < 0 || uint8 > 0xff) {
+            throw new RuntimeException("Out of Boundary");
+        }
+        String hexString = Integer.toHexString(uint8);
+        byte low;
+        byte high;
+        if (hexString.length() > 1) {
+            high = (byte) Integer.parseInt(hexString.substring(0, 1), 16);
+            low = (byte) Integer.parseInt(hexString.substring(1, 2), 16);
+        } else {
+            high = 0;
+            low = (byte) Integer.parseInt(hexString.substring(0, 1), 16);
+        }
+        byte[] result = new byte[]{high, low};
+        return result;
+    }
+
+    /**
+     * Combine 2 bytes (high byte and low byte) to one whole byte
+     *
+     * @param high the high byte
+     * @param low  the low byte
+     * @return the whole byte
+     */
+    public static byte combine2bytesToOne(byte high, byte low) {
+        if (high < 0 || high > 0xf || low < 0 || low > 0xf) {
+            throw new RuntimeException("Out of Boundary");
+        }
+        return (byte) (high << 4 | low);
+    }
+
+    /**
+     * Combine 2 bytes (high byte and low byte) to
+     *
+     * @param high the high byte
+     * @param low  the low byte
+     * @return the char(u8)
+     */
+    public static char combine2bytesToU16(byte high, byte low) {
+        char highU8 = convertByte2Uint8(high);
+        char lowU8 = convertByte2Uint8(low);
+        return (char) (highU8 << 8 | lowU8);
+    }
+
+    /**
+     * Generate the random byte to be sent
+     *
+     * @return the random byte
+     */
+    private static byte randomByte() {
+        return (byte) (127 - new Random().nextInt(256));
+    }
+
+    /**
+     * Generate the random byte to be sent
+     *
+     * @param len the len presented by u8
+     * @return the byte[] to be sent
+     */
+    public static byte[] randomBytes(char len) {
+        byte[] data = new byte[len];
+        for (int i = 0; i < len; i++) {
+            data[i] = randomByte();
+        }
+        return data;
+    }
+
+    public static byte[] genSpecBytes(char len) {
+        byte[] data = new byte[len];
+        for (int i = 0; i < len; i++) {
+            data[i] = '1';
+        }
+        return data;
+    }
+
+    /**
+     * Generate the random byte to be sent
+     *
+     * @param len the len presented by byte
+     * @return the byte[] to be sent
+     */
+    public static byte[] randomBytes(byte len) {
+        char u8 = convertByte2Uint8(len);
+        return randomBytes(u8);
+    }
+
+    /**
+     * Generate the specific byte to be sent
+     *
+     * @param len the len presented by byte
+     * @return the byte[]
+     */
+    public static byte[] genSpecBytes(byte len) {
+        char u8 = convertByte2Uint8(len);
+        return genSpecBytes(u8);
+    }
+
+    public static String parseBssid(byte[] bssidBytes, int offset, int count) {
+        byte[] bytes = new byte[count];
+        for (int i = 0; i < count; i++) {
+            bytes[i] = bssidBytes[i + offset];
+        }
+        return parseBssid(bytes);
+    }
+
+    /**
+     * parse "24,-2,52,-102,-93,-60" to "18,fe,34,9a,a3,c4"
+     * parse the bssid from hex to String
+     *
+     * @param bssidBytes the hex bytes bssid, e.g. {24,-2,52,-102,-93,-60}
+     * @return the String of bssid, e.g. 18fe349aa3c4
+     */
+    public static String parseBssid(byte[] bssidBytes) {
+        StringBuilder sb = new StringBuilder();
+        int k;
+        String hexK;
+        String str;
+        for (int i = 0; i < bssidBytes.length; i++) {
+            k = 0xff & bssidBytes[i];
+            hexK = Integer.toHexString(k);
+            str = ((k < 16) ? ("0" + hexK) : (hexK));
+            System.out.println(str);
+            sb.append(str);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * @param string the string to be used
+     * @return the byte[] of String according to {@link #ESPTOUCH_ENCODING_CHARSET}
+     */
+    public static byte[] getBytesByString(String string) {
+        try {
+            return string.getBytes(ESPTOUCH_ENCODING_CHARSET);
+        } catch (UnsupportedEncodingException e) {
+            throw new IllegalArgumentException("the charset is invalid");
+        }
+    }
+
+    private static void test_splitUint8To2bytes() {
+        // 20 = 0x14
+        byte[] result = splitUint8To2bytes((char) 20);
+        if (result[0] == 1 && result[1] == 4) {
+            System.out.println("test_splitUint8To2bytes(): pass");
+        } else {
+            System.out.println("test_splitUint8To2bytes(): fail");
+        }
+    }
+
+    private static void test_combine2bytesToOne() {
+        byte high = 0x01;
+        byte low = 0x04;
+        if (combine2bytesToOne(high, low) == 20) {
+            System.out.println("test_combine2bytesToOne(): pass");
+        } else {
+            System.out.println("test_combine2bytesToOne(): fail");
+        }
+    }
+
+    private static void test_convertChar2Uint8() {
+        byte b1 = 'a';
+        // -128: 1000 0000 should be 128 in unsigned char
+        // -1: 1111 1111 should be 255 in unsigned char
+        byte b2 = (byte) -128;
+        byte b3 = (byte) -1;
+        if (convertByte2Uint8(b1) == 97 && convertByte2Uint8(b2) == 128 && convertByte2Uint8(b3) == 255) {
+            System.out.println("test_convertChar2Uint8(): pass");
+        } else {
+            System.out.println("test_convertChar2Uint8(): fail");
+        }
+    }
+
+    private static void test_convertUint8toByte() {
+        char c1 = 'a';
+        // 128: 1000 0000 should be -128 in byte
+        // 255: 1111 1111 should be -1 in byte
+        char c2 = 128;
+        char c3 = 255;
+        if (convertUint8toByte(c1) == 97 && convertUint8toByte(c2) == -128 && convertUint8toByte(c3) == -1) {
+            System.out.println("test_convertUint8toByte(): pass");
+        } else {
+            System.out.println("test_convertUint8toByte(): fail");
+        }
+    }
+
+    private static void test_parseBssid() {
+        byte b[] = {15, -2, 52, -102, -93, -60};
+        if (parseBssid(b).equals("0ffe349aa3c4")) {
+            System.out.println("test_parseBssid(): pass");
+        } else {
+            System.out.println("test_parseBssid(): fail");
+        }
+    }
+
+    public static void main(String args[]) {
+        test_convertUint8toByte();
+        test_convertChar2Uint8();
+        test_splitUint8To2bytes();
+        test_combine2bytesToOne();
+        test_parseBssid();
+    }
+
+}

+package com.xgimi.smartscreen.confignetwork.util;
+
+import java.util.zip.Checksum;
+
+public class CRC8 implements Checksum {
+
+    private final short init;
+
+    private static final short[] crcTable = new short[256];
+
+    private short value;
+
+    private static final short CRC_POLYNOM = 0x8c;
+
+    private static final short CRC_INITIAL = 0x00;
+
+    static {
+        for (int dividend = 0; dividend < 256; dividend++) {
+            int remainder = dividend;// << 8;
+            for (int bit = 0; bit < 8; ++bit)
+                if ((remainder & 0x01) != 0)
+                    remainder = (remainder >>> 1) ^ CRC_POLYNOM;
+                else
+                    remainder >>>= 1;
+            crcTable[dividend] = (short) remainder;
+        }
+    }
+
+    public CRC8() {
+        this.value = this.init = CRC_INITIAL;
+    }
+
+    @Override
+    public void update(byte[] buffer, int offset, int len) {
+        for (int i = 0; i < len; i++) {
+            int data = buffer[offset + i] ^ value;
+            value = (short) (crcTable[data & 0xff] ^ (value << 8));
+        }
+    }
+
+    /**
+     * Updates the current checksum with the specified array of bytes.
+     * Equivalent to calling <code>update(buffer, 0, buffer.length)</code>.
+     *
+     * @param buffer the byte array to update the checksum with
+     */
+    public void update(byte[] buffer) {
+        update(buffer, 0, buffer.length);
+    }
+
+    @Override
+    public void update(int b) {
+        update(new byte[]{(byte) b}, 0, 1);
+    }
+
+    @Override
+    public long getValue() {
+        return value & 0xff;
+    }
+
+    @Override
+    public void reset() {
+        value = init;
+    }
+
+}

+package com.xgimi.smartscreen.confignetwork.util;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class NetUtil {
+
+    /**
+     * 判断网络是否连接
+     *
+     * @param context
+     * @return
+     */
+    public static boolean isConnected(Context context) {
+
+        ConnectivityManager connectivity = (ConnectivityManager) context
+                .getSystemService(Context.CONNECTIVITY_SERVICE);
+
+        if (null != connectivity) {
+
+            NetworkInfo info = connectivity.getActiveNetworkInfo();
+            if (null != info && info.isConnected()) {
+                if (info.getState() == NetworkInfo.State.CONNECTED) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 判断是否是wifi连接
+     */
+    public static boolean isWifi(Context context) {
+        ConnectivityManager cm = (ConnectivityManager) context
+                .getSystemService(Context.CONNECTIVITY_SERVICE);
+
+        if (cm == null)
+            return false;
+        return cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
+    }
+
+    /**
+     * get the local ip address by Android System
+     *
+     * @param context the context
+     * @return the local ip addr allocated by Ap
+     */
+    public static InetAddress getLocalInetAddress(Context context) {
+        WifiManager wm = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
+        WifiInfo wifiInfo = wm.getConnectionInfo();
+        int localAddrInt = wifiInfo.getIpAddress();
+        String localAddrStr = __formatString(localAddrInt);
+        InetAddress localInetAddr = null;
+        try {
+            localInetAddr = InetAddress.getByName(localAddrStr);
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
+        return localInetAddr;
+    }
+
+    private static String __formatString(int value) {
+        String strValue = "";
+        byte[] ary = __intToByteArray(value);
+        for (int i = ary.length - 1; i >= 0; i--) {
+            strValue += (ary[i] & 0xFF);
+            if (i > 0) {
+                strValue += ".";
+            }
+        }
+        return strValue;
+    }
+
+    private static byte[] __intToByteArray(int value) {
+        byte[] b = new byte[4];
+        for (int i = 0; i < 4; i++) {
+            int offset = (b.length - 1 - i) * 8;
+            b[i] = (byte) ((value >>> offset) & 0xFF);
+        }
+        return b;
+    }
+
+    /**
+     * parse InetAddress
+     *
+     * @param inetAddrBytes
+     * @return
+     */
+    public static InetAddress parseInetAddr(byte[] inetAddrBytes, int offset, int count) {
+        InetAddress inetAddress = null;
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < count; i++) {
+            sb.append(Integer.toString(inetAddrBytes[offset + i] & 0xff));
+            if (i != count - 1) {
+                sb.append('.');
+            }
+        }
+        try {
+            inetAddress = InetAddress.getByName(sb.toString());
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
+        return inetAddress;
+    }
+
+    /**
+     * parse bssid
+     *
+     * @param bssid the bssid
+     * @return byte converted from bssid
+     */
+    public static byte[] parseBssid2bytes(String bssid) {
+        String bssidSplits[] = bssid.split(":");
+        byte[] result = new byte[bssidSplits.length];
+        for (int i = 0; i < bssidSplits.length; i++) {
+            result[i] = (byte) Integer.parseInt(bssidSplits[i], 16);
+        }
+        return result;
+    }
+}

+package com.xgimi.smartscreen.service;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.text.TextUtils;
+import android.util.Log;
+import android.widget.Toast;
+import com.gimi.common.cinema.model.MessageEvent;
+import com.google.gson.Gson;
+import com.xgimi.smartscreen.SmartScreenBean;
+import com.xgimi.smartscreen.confignetwork.ChTask;
+import com.xgimi.smartscreen.confignetwork.IChListener;
+import com.xgimi.smartscreen.confignetwork.IChResult;
+import com.xgimi.smartscreen.confignetwork.IChTask;
+import com.xgimi.smartscreen.confignetwork.task.__IChTask;
+import com.xgimi.smartscreen.confignetwork.util.NetUtil;
+import org.greenrobot.eventbus.EventBus;
+import org.greenrobot.eventbus.Subscribe;
+import org.greenrobot.eventbus.ThreadMode;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * Created by Administrator on 2016/7/26.
+ */
+public class ConfigService extends Service {
+
+    private String TAG = "ConfigService";
+    private WifiAdminSimple mWifiAdmin;
+    private String mDeviceIp;
+    private int configStat = 0;
+    private Timer firstTimer;
+    private long waitTime;
+    private int findWifiInfoCount = 0;
+    private boolean hasTask = false;
+    SmartScreenBean smartScreen;
+
+    private int state;
+    MessageThread messageThread;
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        Log.d(TAG, "onCreate");
+        EventBus.getDefault().register(this);
+
+        configStat = 0;
+        IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
+        registerReceiver(netStateChange, filter);
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        Log.d(TAG, "onStartCommand");
+        if (intent == null)
+            return super.onStartCommand(intent, flags, startId);
+        if (intent.getIntExtra("boot", 0) == 1) {
+            waitTime = System.currentTimeMillis();
+            firstTimer = new Timer();
+            firstTimer.scheduleAtFixedRate(new TimerTask() {
+                @Override
+                public void run() {
+                    Log.e(TAG, "count time....");
+                    if (System.currentTimeMillis() - waitTime > 2 * 60 * 1000) {
+                        hasTask = false;
+                        firstTimer.cancel();
+                        firstTimer = null;
+                    }
+                }
+            }, 0, 1000);
+            state = SmartScreenBean.DOWNACTION;
+            hasTask = true;
+            getNetStat();
+        }
+
+        String action = intent.getAction();
+        if ("com.xgimi.smartscreen.ACTION.CONTROL".equals(action)) {
+            state = intent.getIntExtra("CONTROL", -1);
+            String ip = intent.getStringExtra("CONTROLIP");
+            if (state >= 0) {
+                Control(ip, state);
+            }
+        } else if ("com.xgimi.smartscreen.ACTION.SEARCH".equals(action)) {
+            new SearchAsyncTask().execute();
+        } else if ("com.xgimi.smartscreen.ACTION.BIND".equals(action)) {
+            String bindInfo = intent.getStringExtra("BINDINFO");
+            XgimiSettingsSP.putString(ConfigService.this, "BINDINFO", bindInfo);
+            Intent notifyIntent = new Intent("com.xgimi.smartscreen.ACTION.DEVICEBIND");
+            sendBroadcast(notifyIntent);
+        }/*else if("com.xgimi.smartscreen.ACTION.POWEROFF".equals(action)){
+            state = SmartScreenBean.UPACTION;
+            hasTask = true;
+            String bindInfo = XgimiSettingsSP.getString(ConfigService.this,"BINDINFO");
+            if(!StringUtils.isEmpty(bindInfo)){
+                Gson gson = new Gson();
+                try {
+                    smartScreen = gson.fromJson(bindInfo,SmartScreenBean.class);
+                    if(smartScreen!=null&&!StringUtils.isEmpty(smartScreen.ip)){
+                        handler.sendEmptyMessage(999);
+                        handler.sendEmptyMessageDelayed(999,300);
+                        handler.sendEmptyMessageDelayed(999,600);
+                        handler.sendEmptyMessageDelayed(999,900);
+                    }
+                }catch (Exception e){
+                    e.printStackTrace();
+                }
+            }
+        }*/
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    private void Control(String ip, int stat) {
+        if (messageThread == null)
+            messageThread = new MessageThread();
+        messageThread.setIp(ip);
+        messageThread.setMode(stat);
+        new Thread(messageThread).start();
+    }
+
+    public class MessageThread implements Runnable {
+        final int PORT = 8009;
+        String cmd, ip;
+
+        public void setIp(String ip) {
+            this.ip = ip;
+        }
+
+        public void setMode(int mode) {
+            JSONObject dataUp = new JSONObject();
+            try {
+                dataUp.put("cmd", 2);
+                dataUp.put("action", mode);
+                cmd = dataUp.toString();
+            } catch (JSONException e) {
+                e.printStackTrace();
+                cmd = null;
+            }
+        }
+
+        @Override
+        public void run() {
+            if (TextUtils.isEmpty(cmd)) {
+                return;
+            }
+            BufferedReader br = null;
+            PrintWriter pw = null;
+            Socket socket = null;
+            try {
+                socket = new Socket(ip, PORT);
+                socket.setSoTimeout(1000);
+                br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+                pw = new PrintWriter(socket.getOutputStream());
+                pw.write(cmd);
+                pw.flush();
+                String data = null;
+                while ((data = br.readLine()) != null) {
+                    Log.i(TAG, "接收到的数据：" + data);
+                    Message msg = new Message();
+                    msg.what = 0x123;
+                    msg.obj = data;
+                    handler.sendMessage(msg);
+                }
+            } catch (SocketTimeoutException e) {
+                Log.i(TAG, "网络连接超时！");
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                try {
+                    if (pw != null) {
+                        pw.close();
+                    }
+                    if (br != null) {
+                        br.close();
+                    }
+                    if (socket != null) {
+                        socket.close();
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+    Handler handler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            super.handleMessage(msg);
+            if (msg.what == 998) {
+                Toast.makeText(ConfigService.this, "recv ", Toast.LENGTH_SHORT).show();
+            } else if (msg.what == 999) {
+                Log.e(TAG, "shut down !!!");
+                Control(smartScreen.ip, state);
+            } else if (msg.what == 1000) {
+                WifiInfo wifiInfo = (WifiInfo) msg.obj;
+                startConfig(wifiInfo.Ssid, wifiInfo.Password);
+            } else if (msg.what == 0x123) {
+                String data = (msg.obj).toString();
+                try {
+                    JSONObject jsonObject = new JSONObject(data);
+                    int cmd = jsonObject.getInt("cmd");
+                    if (cmd == 2) {
+                        int result = jsonObject.getInt("result");
+                        if (result == 1) { //成功
+                            Log.e(TAG, "操作成功");
+                        } else if (result == 0) {  //失败
+                            Log.e(TAG, "操作失败");
+                        }
+                    }
+                } catch (JSONException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    };
+
+    private void getNetStat() {
+        Log.d(TAG, "getNetStat");
+        int stat = XgimiSettingsSP.getInt(ConfigService.this, "AUTOSCREEN");
+        if (stat == 0) {
+            return;
+        }
+        if (NetUtil.isConnected(ConfigService.this)) {
+            Log.e(TAG, "SearchAsyncTask");
+            new SearchAsyncTask().execute();
+        }
+    }
+
+    private BroadcastReceiver netStateChange = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (intent == null) {
+                return;
+            }
+            String action = intent.getAction();
+            if (ConnectivityManager.CONNECTIVITY_ACTION.equals(action)) {
+                Log.d(TAG, "网络状态已经改变");
+                if (NetUtil.isConnected(ConfigService.this)) {
+                    new SearchAsyncTask().execute();
+                }
+            }
+        }
+    };
+
+    private void findWifiInfo() {
+        findWifiInfoCount++;
+        Log.d(TAG, "findWifiInfo" + findWifiInfoCount);
+        if (mWifiAdmin == null) {
+            mWifiAdmin = new WifiAdminSimple(this);
+        }
+        String apSsid = mWifiAdmin.getWifiConnectedSsid();
+        if (TextUtils.isEmpty(apSsid)) {
+            return;
+        }
+    }
+
+    private void startConfig(String apSsid, String apPassword) {
+        Log.d(TAG, "startConfig");
+        String apBssid = mWifiAdmin.getWifiConnectedBssid();
+        String isSsidHiddenStr = "YES";
+        int[] tastResultCount = {0, 1, 2, 3, 4, 5};
+        String taskResultCountStr = Integer.toString(tastResultCount[1]); //设置任务的数量为1个
+        if (__IChTask.DEBUG) {
+            Log.d(TAG, "mBtnConfig is clicked, mEdtApSsid = " + apSsid + ", " + " mEdtApPassword = " + apPassword);
+        }
+        new AsyncTask3().execute(apSsid, apBssid, apPassword, isSsidHiddenStr, taskResultCountStr);
+    }
+
+    private void onChResultAddedPerform(final IChResult result) {
+        String text = result.getBssid() + " 已连接到wifi";
+        Log.e(TAG, "onChResultAddedPerform:" + text);
+    }
+
+    private IChListener myListener = new IChListener() {
+
+        @Override
+        public void onChResultAdded(final IChResult result) {
+            onChResultAddedPerform(result);
+        }
+    };
+
+    private class AsyncTask3 extends AsyncTask<String, Void, List<IChResult>> {
+
+        private IChTask mChTask;
+        // without the lock, if the user tap confirm and cancel quickly enough,
+        // the bug will arise. the reason is follows:
+        // 0. task is starting created, but not finished
+        // 1. the task is cancel for the task hasn't been created, it do nothing
+        // 2. task is created
+        // 3. Oops, the task should be cancelled, but it is running
+        private final Object mLock = new Object();
+
+        @Override
+        protected List<IChResult> doInBackground(String... params) {
+            int taskResultCount = -1;
+            synchronized (mLock) {
+                String apSsid = params[0];
+                String apBssid = params[1];
+                String apPassword = params[2];
+                String isSsidHiddenStr = params[3];
+                String taskResultCountStr = params[4];
+                boolean isSsidHidden = false;
+                if (isSsidHiddenStr.equals("YES")) {
+                    isSsidHidden = true;
+                }
+                taskResultCount = Integer.parseInt(taskResultCountStr);
+                mChTask = new ChTask(apSsid, apBssid, apPassword, isSsidHidden, ConfigService.this);
+                mChTask.setChListener(myListener);
+            }
+            List<IChResult> resultList = mChTask.executeForResults(taskResultCount);
+            return resultList;
+        }
+
+        @Override
+        protected void onPostExecute(List<IChResult> result) {
+            IChResult firstResult = result.get(0);
+            // check whether the task is cancelled and no results received
+            Log.e(TAG, "onPostExecute IChResult");
+            if (!firstResult.isCancelled()) {
+                int count = 0;
+                // max results to be displayed, if it is more than maxDisplayCount,
+                // just show the count of redundant ones
+                final int maxDisplayCount = 5;
+                // the task received some results including cancelled while
+                // executing before receiving enough results
+                String ip = "";
+                if (firstResult.isSuc()) {
+                    StringBuilder sb = new StringBuilder();
+                    for (IChResult resultInList : result) {
+                        sb.append("配置成功" + "\n" + "BSSID = " + resultInList.getBssid() + "\n" + "InetAddress = " + resultInList.getInetAddress().getHostAddress());
+                        ip = resultInList.getInetAddress().getHostAddress();
+                        count++;
+                        if (count >= maxDisplayCount) {
+                            break;
+                        }
+                    }
+                    if (count < result.size()) {
+                        sb.append("\n有 " + (result.size() - count) + " 个结果未显示\n");
+                    }
+                    Log.e(TAG, "test:start SearchAsyncTask;" + sb.toString());
+                    if (hasTask)
+                        Control(ip, state);
+                } else {
+                    Log.e(TAG, "onPostExecute isSuc = false");
+                }
+            } else {
+                Log.e(TAG, "onPostExecute isCancelled");
+            }
+        }
+    }
+
+    private class SearchAsyncTask extends AsyncTask<Void, Integer, String> {
+        InetAddress deviceAddress = null;
+        DatagramSocket socket = null;
+        boolean isSearching = false;
+
+        @Override
+        protected String doInBackground(Void... params) {
+            isSearching = true;
+            try {
+                socket = new DatagramSocket();
+            } catch (SocketException e) {
+                e.printStackTrace();
+            }
+            //接收
+            Thread receiveThread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+
+                    byte[] dataReceive = new byte[1024];
+                    DatagramPacket packetReceive = new DatagramPacket(dataReceive, dataReceive.length);
+
+                    try {
+                        socket.receive(packetReceive);
+                        String reply = new String(dataReceive, 0, packetReceive.getLength());
+                        if (reply.contains("I'm a screen Controller")) {
+                            isSearching = false;
+                            deviceAddress = packetReceive.getAddress();
+                        }
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                        Log.i(TAG, "receive...cnt" + e.toString());
+                    }
+                }
+
+            });
+            receiveThread.start();
+            int cnt = 3; //搜索次数
+
+            while (isSearching) {
+                Log.i(TAG, "开始搜索...cnt" + cnt);
+                if (--cnt == 0) {
+                    break;
+                }
+                //发送
+                String data = "Are You Screen Controller?";
+                DatagramPacket packetSend = null;
+                try {
+                    packetSend = new DatagramPacket(data.getBytes(), data.getBytes().length,
+                            InetAddress.getByName("255.255.255.255"), 12419);
+                } catch (UnknownHostException e) {
+                    e.printStackTrace();
+                }
+
+                try {
+                    socket.send(packetSend);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    Log.e(TAG, "send IOException" + e.toString());
+                }
+
+                try {
+                    Thread.sleep(500);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                    Log.e(TAG, "sleep InterruptedException" + e.toString());
+                }
+            }
+            receiveThread.interrupt();
+            if (deviceAddress != null) {
+                return deviceAddress.toString().substring(1);  //去除ip地址前的斜杠
+            } else {
+                return null;
+            }
+        }
+
+        @Override
+        protected void onPostExecute(String s) {
+            super.onPostExecute(s);
+            Log.e(TAG, "ip:" + s);
+            if (!TextUtils.isEmpty(s)) {
+                SmartScreenBean smartScreenBean = new SmartScreenBean();
+                smartScreenBean.ip = s;
+                smartScreenBean.name = "极米智能幕布";
+                smartScreenBean.state = 0;
+                String bindInfo = new Gson().toJson(smartScreenBean, SmartScreenBean.class);
+                XgimiSettingsSP.putString(ConfigService.this, "BINDINFO", bindInfo);
+                Intent notifyIntent = new Intent("com.xgimi.smartscreen.ACTION.DEVICEBIND");
+                sendBroadcast(notifyIntent);
+                if (hasTask) {
+                    Control(s, state);
+                    hasTask = false;
+                }
+            } else {
+                Log.e(TAG, "没有发现设备！");
+                XgimiSettingsSP.putString(ConfigService.this, "BINDINFO", "");
+                Intent notifyIntent = new Intent("com.xgimi.smartscreen.ACTION.NODEVICE");
+                sendBroadcast(notifyIntent);
+            }
+        }
+    }
+
+
+    @Override
+    public void onDestroy() {
+        Log.e(TAG, "onDestroy");
+        EventBus.getDefault().unregister(this);
+        if (firstTimer != null) {
+            firstTimer.cancel();
+            firstTimer = null;
+        }
+        unregisterReceiver(netStateChange);
+        handler.removeCallbacksAndMessages(null);
+        super.onDestroy();
+    }
+
+
+    @Subscribe(threadMode = ThreadMode.MAIN)
+    public void onMoonEvent(MessageEvent messageEvent) {
+        switch (messageEvent.getEventId()) {
+            case SmartScreenBean.UPACTION:
+                Log.d(TAG, "SmartScreenBean.UPACTION");
+                Control(messageEvent.getMessage(), messageEvent.getEventId());
+                break;
+            case SmartScreenBean.DOWNACTION:
+                Log.d(TAG, "SmartScreenBean.DOWNACTION");
+                Control(messageEvent.getMessage(), messageEvent.getEventId());
+                break;
+            case SmartScreenBean.STOPACTION:
+                Log.d(TAG, "SmartScreenBean.STOPACTION");
+                Control(messageEvent.getMessage(), messageEvent.getEventId());
+                break;
+        }
+    }
+}

+package com.xgimi.smartscreen.service;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+
+public class WifiAdminSimple {
+
+    private final Context mContext;
+
+    public WifiAdminSimple(Context context) {
+        mContext = context;
+    }
+
+    public String getWifiConnectedSsid() {
+        WifiInfo mWifiInfo = getConnectionInfo();
+        String ssid = null;
+        if (mWifiInfo != null && isWifiConnected()) {
+            int len = mWifiInfo.getSSID().length();
+            if (mWifiInfo.getSSID().startsWith("\"") && mWifiInfo.getSSID().endsWith("\"")) {
+                ssid = mWifiInfo.getSSID().substring(1, len - 1);
+            } else {
+                ssid = mWifiInfo.getSSID();
+            }
+
+        }
+        return ssid;
+    }
+
+    public String getWifiConnectedBssid() {
+        WifiInfo mWifiInfo = getConnectionInfo();
+        String bssid = null;
+        if (mWifiInfo != null && isWifiConnected()) {
+            bssid = mWifiInfo.getBSSID();
+        }
+        return bssid;
+    }
+
+    // get the wifi info which is "connected" in wifi-setting
+    private WifiInfo getConnectionInfo() {
+        WifiManager mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
+        WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
+        return wifiInfo;
+    }
+
+    private boolean isWifiConnected() {
+        NetworkInfo mWiFiNetworkInfo = getWifiNetworkInfo();
+        boolean isWifiConnected = false;
+        if (mWiFiNetworkInfo != null) {
+            isWifiConnected = mWiFiNetworkInfo.isConnected();
+        }
+        return isWifiConnected;
+    }
+
+    private NetworkInfo getWifiNetworkInfo() {
+        ConnectivityManager mConnectivityManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
+        NetworkInfo mWiFiNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        return mWiFiNetworkInfo;
+    }
+}

+package com.xgimi.smartscreen.service;
+
+/**
+ * Created by Administrator on 2016/7/26.
+ */
+public class WifiInfo {
+    public String Ssid="";
+    public String Password="";
+}

+package com.xgimi.smartscreen.service;
+
+/**
+ * Created by Administrator on 2016/7/26.
+ */
+
+import android.util.Log;
+
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class WifiManage {
+
+    public List<WifiInfo> Read() throws Exception {
+        List<WifiInfo> wifiInfos=new ArrayList<WifiInfo>();
+
+        Process process = null;
+        DataOutputStream dataOutputStream = null;
+        DataInputStream dataInputStream = null;
+        StringBuffer wifiConf = new StringBuffer();
+        try {
+            process = Runtime.getRuntime().exec("sh");
+            dataOutputStream = new DataOutputStream(process.getOutputStream());
+            dataInputStream = new DataInputStream(process.getInputStream());
+            dataOutputStream
+                    .writeBytes("cat /system/etc/wifiinfo/wpa_supplicant.conf\n");
+            dataOutputStream.writeBytes("exit\n");
+            dataOutputStream.flush();
+            InputStreamReader inputStreamReader = new InputStreamReader(
+                    dataInputStream, "UTF-8");
+            BufferedReader bufferedReader = new BufferedReader(
+                    inputStreamReader);
+            String line = null;
+            while ((line = bufferedReader.readLine()) != null) {
+                wifiConf.append(line);
+                Log.e("TAG","line"+line);
+            }
+            bufferedReader.close();
+            inputStreamReader.close();
+            process.waitFor();
+        } catch (Exception e) {
+            throw e;
+        } finally {
+            try {
+                if (dataOutputStream != null) {
+                    dataOutputStream.close();
+                }
+                if (dataInputStream != null) {
+                    dataInputStream.close();
+                }
+                if(process!=null)
+                    process.destroy();
+            } catch (Exception e) {
+                throw e;
+            }
+        }
+
+
+        Pattern network = Pattern.compile("network=\\{([^\\}]+)\\}", Pattern.DOTALL);
+        Matcher networkMatcher = network.matcher(wifiConf.toString() );
+        while (networkMatcher.find() ) {
+            String networkBlock = networkMatcher.group();
+            Pattern ssid = Pattern.compile("ssid=\"([^\"]+)\"");
+            Matcher ssidMatcher = ssid.matcher(networkBlock);
+
+            if (ssidMatcher.find() ) {
+                WifiInfo wifiInfo=new WifiInfo();
+                wifiInfo.Ssid=ssidMatcher.group(1);
+                Pattern psk = Pattern.compile("psk=\"([^\"]+)\"");
+                Matcher pskMatcher = psk.matcher(networkBlock);
+                if (pskMatcher.find() ) {
+                    wifiInfo.Password=pskMatcher.group(1);
+                } else {
+                    wifiInfo.Password="无密码";
+                }
+                wifiInfos.add(wifiInfo);
+            }
+
+        }
+
+        return wifiInfos;
+    }
+
+}

+package com.xgimi.smartscreen.service;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+public class XgimiSettingsSP {
+
+    private static final String PREFERENCE_NAME = "local_settings";  //sp名字
+
+    private static final String PKG_NAME = "com.android.settings";  //设置包名
+
+    public static final String ID_USER_NAME = "xgimi_out_username";
+
+
+    /**
+     * put string preferences
+     *
+     * @param context
+     * @param key     The name of the preference to modify
+     * @param value   The new value for the preference
+     * @return True if the new values were successfully written to persistent
+     * storage.
+     */
+    public static boolean putString(Context context, String key, String value) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences settings = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_WRITEABLE | Context.MODE_MULTI_PROCESS);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putString(key, value);
+            return editor.commit();
+        } catch (Exception e) {
+
+        }
+        return false;
+    }
+
+    /**
+     * get string preferences
+     *
+     * @param context
+     * @param key     The name of the preference to retrieve
+     * @return The preference value if it exists, or null. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a string
+     * @see #getString(Context, String, String)
+     */
+    public static String getString(Context context, String key) {
+        return getString(context, key, "");
+    }
+
+    /**
+     * get string preferences
+     *
+     * @param context
+     * @param key          The name of the preference to retrieve
+     * @param defaultValue Value to return if this preference does not exist
+     * @return The preference value if it exists, or defValue. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a string
+     */
+    public static String getString(Context context, String key, String defaultValue) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences share = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_READABLE | Context.MODE_MULTI_PROCESS);
+            return share.getString(key, defaultValue);
+        } catch (Exception e) {
+
+        }
+        return defaultValue;
+    }
+
+    /**
+     * put int preferences
+     *
+     * @param context
+     * @param key     The name of the preference to modify
+     * @param value   The new value for the preference
+     * @return True if the new values were successfully written to persistent
+     * storage.
+     */
+    public static boolean putInt(Context context, String key, int value) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences settings = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_WRITEABLE | Context.MODE_MULTI_PROCESS);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putInt(key, value);
+            return editor.commit();
+        } catch (Exception e) {
+
+        }
+        return false;
+    }
+
+    /**
+     * get int preferences
+     *
+     * @param context
+     * @param key     The name of the preference to retrieve
+     * @return The preference value if it exists, or -1. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a int
+     * @see #getInt(Context, String, int)
+     */
+    public static int getInt(Context context, String key) {
+        return getInt(context, key, -1);
+    }
+
+    /**
+     * get int preferences
+     *
+     * @param context
+     * @param key          The name of the preference to retrieve
+     * @param defaultValue Value to return if this preference does not exist
+     * @return The preference value if it exists, or defValue. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a int
+     */
+    public static int getInt(Context context, String key, int defaultValue) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences share = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_READABLE | Context.MODE_MULTI_PROCESS);
+            return share.getInt(key, defaultValue);
+        } catch (Exception e) {
+
+        }
+        return defaultValue;
+    }
+
+    /**
+     * put long preferences
+     *
+     * @param context
+     * @param key     The name of the preference to modify
+     * @param value   The new value for the preference
+     * @return True if the new values were successfully written to persistent
+     * storage.
+     */
+    public static boolean putLong(Context context, String key, long value) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences settings = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_WRITEABLE | Context.MODE_MULTI_PROCESS);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putLong(key, value);
+            return editor.commit();
+        } catch (Exception e) {
+
+        }
+        return false;
+    }
+
+    /**
+     * get long preferences
+     *
+     * @param context
+     * @param key     The name of the preference to retrieve
+     * @return The preference value if it exists, or -1. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a long
+     * @see #getLong(Context, String, long)
+     */
+    public static long getLong(Context context, String key) {
+        return getLong(context, key, -1);
+    }
+
+    /**
+     * get long preferences
+     *
+     * @param context
+     * @param key          The name of the preference to retrieve
+     * @param defaultValue Value to return if this preference does not exist
+     * @return The preference value if it exists, or defValue. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a long
+     */
+    public static long getLong(Context context, String key, long defaultValue) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences share = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_READABLE | Context.MODE_MULTI_PROCESS);
+            return share.getLong(key, defaultValue);
+        } catch (Exception e) {
+
+        }
+        return defaultValue;
+    }
+
+    /**
+     * put float preferences
+     *
+     * @param context
+     * @param key     The name of the preference to modify
+     * @param value   The new value for the preference
+     * @return True if the new values were successfully written to persistent
+     * storage.
+     */
+    public static boolean putFloat(Context context, String key, float value) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences settings = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_WRITEABLE | Context.MODE_MULTI_PROCESS);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putFloat(key, value);
+            return editor.commit();
+        } catch (Exception e) {
+
+        }
+        return false;
+    }
+
+    /**
+     * get float preferences
+     *
+     * @param context
+     * @param key     The name of the preference to retrieve
+     * @return The preference value if it exists, or -1. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a float
+     * @see #getFloat(Context, String, float)
+     */
+    public static float getFloat(Context context, String key) {
+        return getFloat(context, key, -1);
+    }
+
+    /**
+     * get float preferences
+     *
+     * @param context
+     * @param key          The name of the preference to retrieve
+     * @param defaultValue Value to return if this preference does not exist
+     * @return The preference value if it exists, or defValue. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a float
+     */
+    public static float getFloat(Context context, String key, float defaultValue) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences share = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_READABLE | Context.MODE_MULTI_PROCESS);
+            return share.getFloat(key, defaultValue);
+        } catch (Exception e) {
+
+        }
+        return defaultValue;
+    }
+
+    /**
+     * put boolean preferences
+     *
+     * @param context
+     * @param key     The name of the preference to modify
+     * @param value   The new value for the preference
+     * @return True if the new values were successfully written to persistent
+     * storage.
+     */
+    public static boolean putBoolean(Context context, String key, boolean value) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences settings = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_WRITEABLE | Context.MODE_MULTI_PROCESS);
+            SharedPreferences.Editor editor = settings.edit();
+            editor.putBoolean(key, value);
+            return editor.commit();
+        } catch (Exception e) {
+
+        }
+        return false;
+    }
+
+    /**
+     * get boolean preferences, default is false
+     *
+     * @param context
+     * @param key     The name of the preference to retrieve
+     * @return The preference value if it exists, or false. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a boolean
+     * @see #getBoolean(Context, String, boolean)
+     */
+    public static boolean getBoolean(Context context, String key) {
+        return getBoolean(context, key, false);
+    }
+
+    /**
+     * get boolean preferences
+     *
+     * @param context
+     * @param key          The name of the preference to retrieve
+     * @param defaultValue Value to return if this preference does not exist
+     * @return The preference value if it exists, or defValue. Throws
+     * ClassCastException if there is a preference with this name that
+     * is not a boolean
+     */
+    public static boolean getBoolean(Context context, String key, boolean defaultValue) {
+        try {
+            Context otherAppsContext = context.createPackageContext(PKG_NAME, Context.CONTEXT_IGNORE_SECURITY);
+            SharedPreferences share = otherAppsContext.getSharedPreferences(PREFERENCE_NAME, Context.MODE_WORLD_READABLE | Context.MODE_MULTI_PROCESS);
+            return share.getBoolean(key, defaultValue);
+        } catch (Exception e) {
+
+        }
+        return defaultValue;
+    }
+}

@@ -201,6 +201,28 @@
             </TableRow>
             </TableRow>
             <TableRow android:layout_width="match_parent"
             <TableRow android:layout_width="match_parent"
                       android:layout_marginLeft="40dp"
                       android:layout_marginLeft="40dp"
+                      android:layout_height="wrap_content">
+
+                <Button style="@style/GeneralTextViewTheme"
+                        android:onClick="setLights"
+                        android:visibility="visible"
+                        android:textColor="@color/black"
+                        android:text="@string/set_sm_light"/>
+
+                <Button style="@style/GeneralTextViewTheme"
+                        android:onClick="setSmartScreen"
+                        android:visibility="visible"
+                        android:textColor="@color/black"
+                        android:text="设置智能幕布"/>
+
+                <Button style="@style/GeneralTextViewTheme"
+                        android:onClick="update1905Movies"
+                        android:visibility="invisible"
+                        android:textColor="@color/black"
+                        android:text="@string/update_1905_source"/>
+            </TableRow>
+            <TableRow android:layout_width="match_parent"
+                      android:layout_marginLeft="40dp"
                       android:visibility="gone"
                       android:visibility="gone"
                       android:layout_height="wrap_content">
                       android:layout_height="wrap_content">
 
 

+<!--
+  ~ Copyright 2017 wugian
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:background="@android:color/white"
+              android:orientation="vertical">
+
+    <RelativeLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+    >
+
+        <ImageView
+                android:id="@+id/img_header_menu_left"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_alignParentStart="true"
+                android:layout_centerVertical="true"
+                android:layout_marginStart="10dp"
+                android:contentDescription="@null"/>
+
+        <TextView
+                android:id="@+id/txt_header_title"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_alignWithParentIfMissing="false"
+                android:layout_centerHorizontal="true"
+                android:layout_centerInParent="true"
+                android:layout_centerVertical="true"
+                android:layout_marginEnd="30dp"
+                android:layout_marginStart="30dp"
+                android:gravity="center_vertical"
+                android:singleLine="true"
+                android:text="配置智能幕布"
+                android:textAlignment="center"
+                android:textColor="@android:color/black"
+                android:textSize="18sp"/>
+    </RelativeLayout>
+
+    <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginLeft="5dp"
+            android:layout_marginRight="5dp"
+            android:layout_marginTop="15dp"
+            android:orientation="vertical">
+
+
+        <EditText
+                android:id="@+id/ssid_et"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:editable="false"
+                android:ems="10"
+                android:inputType="text"
+                android:labelFor="@+id/txt_mesh_name"
+                android:hint="ssid"/>
+
+        <EditText
+                android:id="@+id/pwd_et"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:ems="10"
+                android:layout_marginTop="10dp"
+                android:inputType="textPassword"
+                android:labelFor="@+id/txt_mesh_password"
+                android:hint="password"/>
+
+
+        <Button
+                android:id="@+id/btn_save"
+                android:layout_width="match_parent"
+                android:layout_height="46dp"
+                android:layout_marginTop="15dp"
+                android:text="开始配置"
+                android:textColor="@android:color/black"
+                android:textSize="18sp"/>
+
+        <Button
+                android:layout_width="match_parent"
+                android:layout_height="46dp"
+                android:layout_marginTop="15dp"
+                android:onClick="matchScreen"
+                android:text="配对幕布"
+                android:textColor="@android:color/black"
+                android:textSize="18sp"/>
+    </LinearLayout>
+    <TextView android:layout_width="match_parent"
+              android:layout_height="wrap_content"
+              android:padding="10dp"
+              android:textColor="@color/red"
+              android:text="请将本机连接到wifi进行配置，或者使用极米助手进行配置!!"
+    />
+
+</LinearLayout>

+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                xmlns:app="http://schemas.android.com/apk/res-auto"
+                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:showIn="@layout/activity_main">
+
+
+    <ListView
+            android:id="@+id/lv_device"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"/>
+
+</RelativeLayout>

+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="400dp"
+    android:layout_height="wrap_content"
+    android:gravity="center_horizontal"
+    android:orientation="vertical">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="32dp"
+        android:background="@color/white"
+        android:gravity="center"
+        android:orientation="vertical">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="幕布控制"
+            android:textColor="@color/black"
+            android:textSize="16sp" />
+
+        <TextView
+            android:id="@+id/tv_dialog_ip"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textColor="@color/black"
+            android:textSize="16sp" />
+
+    </LinearLayout>
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="1dp"
+        android:background="@color/gray" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="90dp">
+
+        <TextView
+            android:id="@+id/tv_device_info"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:padding="5dp"
+            android:textColor="@color/black"
+            android:textSize="14sp" />
+
+    </LinearLayout>
+
+
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="1dp"
+        android:background="@color/gray" />
+
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="48sp">
+
+        <Button
+            android:id="@+id/tv_up"
+            android:layout_width="0dp"
+            android:layout_height="match_parent"
+            android:layout_weight="1"
+            android:gravity="center"
+            android:text="上"
+            android:textColor="@color/g"
+            android:textSize="16sp" />
+
+        <TextView
+            android:layout_width="1dp"
+            android:layout_height="match_parent"
+            android:background="@color/gray" />
+
+        <Button
+            android:id="@+id/tv_down"
+            android:layout_width="0dp"
+            android:layout_height="match_parent"
+            android:layout_weight="1"
+            android:gravity="center"
+            android:text="下"
+            android:textColor="@color/g"
+            android:textSize="16sp" />
+
+    </LinearLayout>
+
+
+</LinearLayout>

+<?xml version="1.0" encoding="utf-8"?>
+<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                                                 xmlns:app="http://schemas.android.com/apk/res-auto"
+                                                 xmlns:tools="http://schemas.android.com/tools"
+                                                 android:layout_width="match_parent"
+                                                 android:layout_height="match_parent"
+                                                 android:fitsSystemWindows="true">
+
+    <android.support.design.widget.AppBarLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:theme="@style/AppTheme.AppBarOverlay">
+
+        <android.support.v7.widget.Toolbar
+                android:id="@+id/toolbar"
+                android:layout_width="match_parent"
+                android:layout_height="?attr/actionBarSize"
+                android:background="@color/g"
+                app:popupTheme="@style/AppTheme.PopupOverlay" />
+
+    </android.support.design.widget.AppBarLayout>
+
+    <include layout="@layout/content_main" />
+
+</android.support.design.widget.CoordinatorLayout>