H3C

package com.rokid.homebase.driver.h3c;
import android.app.Service;
import android.content.Intent;
import android.content.res.Resources;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.support.annotation.Nullable;
import android.util.Log;

import com.rokid.homebase.driver.h3c.entity.ServerPortEntity;

import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;

public class XinHuaService extends Service {
private static DriverHandler mHandler;
private static final String TAG = "H3C";

public final class DriverHandler extends Handler {
    public static final int MSG_UPDATE_PORT = 10;
    public static final int MSG_LUNCH_SERVER_WITH_PORT = 20;
    private int mCounter;
    public DriverHandler(Looper lpr) {
        super(lpr);
        mCounter = 50;
    }

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case MSG_UPDATE_PORT: {
                fetchServerLunchPort(true);
            }
            break;

            case MSG_LUNCH_SERVER_WITH_PORT: {
                ServerPortEntity entity = (ServerPortEntity) msg.obj;
                Log.d(TAG, "recv port resp: " + entity.toString());
                switch (entity.getResponseStatus().getRequestStatus()) {
                    case HttpURLConnection.HTTP_OK: {
                        if (entity.status == 0) {
                            XinhuaServer.lunch(getApplicationContext(), entity.port);
                        } else {
                            Log.e(TAG, "req port status: " + entity.status);
                            // TODO retry mechanism required ...
                            mCounter--;
                            if (mCounter > -1) {
                                mHandler.sendEmptyMessageDelayed(DriverHandler.MSG_UPDATE_PORT,
                                        100L * (50 - mCounter));
                            }
                        }
                    }
                    break;

                    default:
                        Log.e(TAG, "recv response: " + entity.getResponseStatus().getDescription());
                        super.handleMessage(msg);
                        break;
                }
            }
            break;

            default:
                super.handleMessage(msg);
        }
    }
}

public static DriverHandler getMyHandler() {
    return mHandler;
}

private URL getURL(String host, int port, String methods, HashMap<String, String> params)
        throws MalformedURLException, NullPointerException {
    if (port < 1)
        throw new MalformedURLException("illegal port value: " + port);
    if (host == null || host.length() < 1)
        throw new NullPointerException("host is nil ...");

    StringBuffer urlStr = new StringBuffer();
    urlStr.append(host);
    urlStr.append(":");
    urlStr.append(port);
    urlStr.append(methods);
    urlStr.append("?");

    Iterator<String> paramsKeys = params.keySet().iterator();
    while (paramsKeys.hasNext()) {
        String currKey = paramsKeys.next();
        urlStr.append(currKey);
        urlStr.append("=");
        urlStr.append(params.get(currKey));
        if (paramsKeys.hasNext())
            urlStr.append("&");
    }
    Log.d(TAG, "fetched url: " + urlStr.toString());
    return (new URL(urlStr.toString()));
}

@Override
public void onCreate() {
    Log.d(TAG, "----onCreate---XinhuasanService");
    if (mHandler == null) {
        mHandler = new DriverHandler(Looper.getMainLooper());
    }
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Log.d(TAG, "onStartCommand: " );
    if (mHandler != null) {
        mHandler.sendEmptyMessage(DriverHandler.MSG_UPDATE_PORT);
    }
    return Service.START_STICKY;
}

private void fetchServerLunchPort(boolean relunch) {
    // TODO
    // chk whether should relunch server or not ...
    if (XinhuaServer.isServerAlive()) {
        if (!relunch) {
            Log.e(TAG, "server is running ...");
            return;
        } else {
            XinhuaServer.terminate();
        }
    }

    Log.d(TAG, "fetch port to re-lunch server...");
    Resources res = getApplicationContext().getResources();
    final HashMap<String, String> params = new HashMap<String, String>();
    params.put("vendor", res.getString(com.rokid.homebase.driver.h3c.R.string.vendor));
    try {
        URL portUrl = getURL(res.getString(com.rokid.homebase.driver.h3c.R.string.sayhello_host),
                res.getInteger(com.rokid.homebase.driver.h3c.R.integer.sayhello_port),
                res.getString(com.rokid.homebase.driver.h3c.R.string.sayhello_methods),
                params);
        (new HttpRequestThread(res.getInteger(com.rokid.homebase.driver.h3c.R.integer.sayhello_timeout), portUrl)).start();
    } catch (Exception e) {
        e.printStackTrace();
        Log.e(TAG, "failed to re-lunch server for URL problems...");
    }
}

@Nullable
@Override
public IBinder onBind(Intent intent) {
    Log.d(TAG, "onBind: " + intent.getAction());
    return null;
}
}

package com.rokid.homebase.driver.h3c;

import android.os.Message;
import android.util.Log;

import com.rokid.homebase.driver.h3c.entity.ServerPortEntity;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpRequestThread extends Thread {
private URL mURL;
private int mTimeout;
private static final String TAG = "H3C";

public HttpRequestThread(int timeout, URL url) {
    mURL = url;
    mTimeout = timeout;
}

public void setTimeout(int timeout) {
    this.mTimeout = timeout;
}

@Override
public void run() {
    Log.d(TAG, "http request thrd run with id: " + Thread.currentThread().getId());
    try {
        HttpURLConnection conn = (HttpURLConnection) mURL.openConnection();
        conn.setConnectTimeout(mTimeout);
        conn.connect();
        int code = conn.getResponseCode();
        ServerPortEntity entity;
        Log.d(TAG, "-----code:" + code);
        switch (code) {
            case HttpURLConnection.HTTP_OK: {
                entity = new ServerPortEntity(code, handleInput(conn.getInputStream()));
            }
            break;

            default: {
                entity = new ServerPortEntity(code, null);
            }
            break;
        }

        if (XinHuaService.getMyHandler() != null) {
            XinHuaService.DriverHandler hdl = XinHuaService.getMyHandler();
            Message msg = hdl.obtainMessage();
            msg.what = XinHuaService.DriverHandler.MSG_LUNCH_SERVER_WITH_PORT;
            msg.obj = entity;
            hdl.sendMessage(msg);
        }
        conn.disconnect();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

private String handleInput(InputStream in) throws java.io.IOException {
    BufferedReader reader = new BufferedReader(
            new InputStreamReader(in));
    String line;
    String content = "";
    while ((line = reader.readLine()) != null) {
        content += line;
    }
    return content;
}
}

ServerPortEntity方法：

public ServerPortEntity(int code, String json) {
        responseStatus = Status.lookup(code);
        if (json == null || json.length() < 1) {
            status = -1;
            port = -1;
        }
        else {
            try {
                JSONObject obj = new JSONObject(json);
                Log.d("cccc", "ServerPortEntity: "+ obj.toString());
                status = obj.getInt("status");
                JSONObject body = obj.getJSONObject("data");
                port = body.getInt("port");
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

XinhuaServer

package com.rokid.homebase.driver.h3c;

import android.content.Context;
import android.util.Log;

import com.h3c.app.shome.sdk.entity.AirConEntity;
import com.h3c.app.shome.sdk.entity.BindGwListEntity;
import com.h3c.app.shome.sdk.entity.CallResultEntity;
import com.h3c.app.shome.sdk.entity.CentrumLoginEntity;
import com.h3c.app.shome.sdk.entity.CurtainEntity;
import com.h3c.app.shome.sdk.entity.DeviceEntity;
import com.h3c.app.shome.sdk.entity.DeviceListEntity;
import com.h3c.app.shome.sdk.entity.DeviceTypeEnum;
import com.h3c.app.shome.sdk.entity.DimmerEntity;
import com.h3c.app.shome.sdk.entity.ISwitchEntity;
import com.h3c.app.shome.sdk.http.AbsSmartHomeHttp;
import com.h3c.app.shome.sdk.http.RemoteModeHttp;
import com.h3c.app.shome.sdk.service.ISDKCallBack;
import com.h3c.app.shome.sdk.service.RetCodeEnum;
import com.h3c.app.shome.sdk.service.ServiceFactory;
import com.h3c.app.shome.sdk.util.CommonUtils;
import com.rokid.homebase.driver.GwItem;
import com.rokid.homebase.driver.MyApplication;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.nanohttpd.protocols.http.IHTTPSession;
import org.nanohttpd.protocols.http.NanoHTTPD;
import org.nanohttpd.protocols.http.response.Response;
import org.nanohttpd.util.ServerRunner;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

/**
 * Created by DW on 17/2/8.
 */
public class XinhuaServer extends NanoHTTPD {
    private static final String TAG = "H3C";
    private static XinhuaServer sServer = null;
    private Context mCtx;
    private H3CDriver h3cDriver;


public static void lunch(Context ctx, int port) {
    if (sServer == null) {
        sServer = new XinhuaServer(ctx, port);
    }
    if (!sServer.isAlive()) {
        ServerRunner.executeInstance(sServer);
    }
    Log.d(TAG, "-----------sServer.isAlive() : " + sServer.isAlive());
}

public XinhuaServer(Context context, int port) {
    super(port);
    mCtx = context;
    h3cDriver = new H3CDriver();
}

public static boolean isServerAlive() {
    return (sServer != null && sServer.isAlive());
}

public static void terminate() {
    if (sServer != null) {
        sServer.stop();
        sServer = null;
    }
}

//接受网页端的请求返回response给网页端
@Override
public Response serve(IHTTPSession session) {
    super.serve(session);
    Log.d(TAG, " ----serve---- : " + session.getMethod() + "  -----session.getUri():" + session.getUri());
    switch (session.getMethod()) {
        case POST:
            try {
                Map<String, String> headers = session.getHeaders();
                try {
                    Log.d(TAG, "------parseRequest: begin");
                    //url，请求体
                        return parseRequest(session.getUri(), session.getRawJSON());
                } catch (JSONException e) {
                    e.printStackTrace();
                    Log.d(TAG, "------parseRequest: Exception");
                    return DriverResponse.jsonExceptionResponse();
                }
            } catch (Exception e) {
                e.printStackTrace();
                Log.d(TAG, "------session.getHeaders();exception");
                return null;
            }

        default:
            Log.d(TAG, "------default: ");
            return DriverResponse.wrongMethodResponse(
                    mCtx.getResources().getString(com.rokid.homebase.driver.h3c.R.string.response_exception_method_not_allowed));
    }
}

@Override
public void stop() {
    super.stop();
}

private Response parseRequest(String uri, String body) throws JSONException {
    Log.d(TAG, "-------recv uri: " + uri + " ----in thrd: " + Thread.currentThread().getId() + "-----body:" + body.toString());
    JSONObject req = new JSONObject(body);
    Map<String, H3CDevice> devList = new HashMap<String, H3CDevice>();
    //command
    // /list
    // /get
    // /execute
     if ("/command".equalsIgnoreCase(uri)) {
        JSONObject loginExceptionObj = new JSONObject();
        Log.d(TAG, "parseRequest: " + loginExceptionObj.toString());
        JSONObject authObj = req.getJSONObject("params");
        String account = authObj.getString("username");
        String psw = authObj.getString("password");
        String[] password = psw.split("//");
        Log.d(TAG, "parseRequest: psw:" + password[0] + " ,gwpsw:" + password[1]);
        if (account != null && !account.equals("") && psw != null && !psw.equals("")) {
            h3cDriver.gotoLogin(account, password);
        }
        Log.d(TAG, "-----isLogin?" + h3cDriver.isUserLogined());
        if (!h3cDriver.isUserLogined()) {
            loginExceptionObj.put("message", "login failed retry now ...");
            return DriverResponse.customizedResponse(1, loginExceptionObj);
        }
        if (!h3cDriver.isGwInited()) {
            loginExceptionObj.put("message", "gw login failed retry now ...");
            return DriverResponse.customizedResponse(1, loginExceptionObj);
        }
        else {
            return DriverResponse.okResponse(h3cDriver.obtainJsonLogin());
        }
    } else if ("/list".equalsIgnoreCase(uri)) {
        JSONObject loginExceptionObj = new JSONObject();
        Log.d(TAG, "parseRequest: " + loginExceptionObj.toString());
        JSONObject authObj = req.getJSONObject("userAuth");
        String account = authObj.getString("userId");
        String psw = authObj.getString("userToken");
//            String[] password = psw.split("//");
            Log.d(TAG, "parseRequest: psw:" + psw);
            if (account != null && !account.equals("") && psw != null && !psw.equals("")) {
                Log.d(TAG, "-----isLogin?" + h3cDriver.isUserLogined() + "--isGwlogin:" + h3cDriver.isGwInited());
                if (h3cDriver.isGwInited()) {
                    h3cDriver.obtainH3CDevices();
                }
                if (h3cDriver.getDevList() != null && h3cDriver.getDevList().size() > 0) {
                    devList = h3cDriver.getDevList();
                }
            }

        JSONArray jsonList = new JSONArray();
        if (devList == null || devList.size() < 1) {
            JSONObject expObj = new JSONObject();
            expObj.put("message", "no device founded ...");
            return DriverResponse.customizedResponse(1, expObj);
        } else {
            Log.d(TAG, " list size is: " + devList.size());
            Iterator<String> itor = devList.keySet().iterator();
            while (itor.hasNext()) {
                jsonList.put(h3cDriver.getJSONDevices(devList.get(itor.next())));
            }
            return DriverResponse.okResponse(jsonList);
        }
    } else if ("/get".equalsIgnoreCase(uri)) {
        JSONObject devObj = req.getJSONObject("device");
        if (h3cDriver.getDevList() != null && h3cDriver.getDevList().size() > 0) {
            devList = h3cDriver.getDevList();
        }

        if (devList == null) {
            h3cDriver.obtainH3CDevices();
            return DriverResponse.customizedResponse(2, null);
        } else {
            H3CDevice device = devList.get(devObj.getString("deviceId"));
            if (device == null)
                return DriverResponse.customizedResponse(2, null);
            else
                return DriverResponse.okResponse(h3cDriver.getJSONDevice(device));
        }
    } else if ("/execute".equalsIgnoreCase(uri)) {
        JSONObject devObj = req.getJSONObject("device");
        Map<String, DeviceEntity> h3cDevList = new HashMap<String, DeviceEntity>();
        JSONObject controlResultObj = null;
        if (h3cDriver.getDevList() != null && h3cDriver.getDevList().size() > 0) {
            devList = h3cDriver.getDevList();
            h3cDevList = h3cDriver.getH3cDevList();
        }

        if (devList == null) {
            h3cDriver.obtainH3CDevices();
            return DriverResponse.customizedResponse(2, null);
        } else {
            final JSONObject requestActions = req.getJSONObject("action");
            H3CDevice device = devList.get(devObj.getString("deviceId"));
            final DeviceEntity h3cDev = h3cDevList.get(devObj.getString("deviceId"));
            for (H3CDeviceActions h3cAction : device.getActions()) {
//                    Log.d(TAG, "parseRequest: "+h3cAction.getActionName()+" action:"+requestActions.getString(h3cAction.getActionName()));
                    if (requestActions.has(h3cAction.getActionName())) {
                        if (requestActions.getString(h3cAction.getActionName()) != null) {
                            Log.d(TAG, "parseRequest action is :" + requestActions.getString(h3cAction.getActionName()));
                            controlResultObj = h3cDriver.controlH3CDevice(h3cAction.getActionName(),
                                    requestActions.getString(h3cAction.getActionName()), h3cDev, device);
                        }
                    }
                }
            }
            if (controlResultObj != null) {
                return DriverResponse.okResponse(controlResultObj);
            }
            return DriverResponse.customizedResponse(2, null);
        } else {
            JSONObject respObj = new JSONObject();
            respObj.put("message", "no such command ...");
            return DriverResponse.okResponse(respObj);
        }
    }

}

DriverResponse

package com.rokid.homebase.driver.h3c;

import android.util.Log;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.nanohttpd.protocols.http.response.Response;
import org.nanohttpd.protocols.http.response.Status;

public class DriverResponse {
    private static final String TAG="H3C";
    private static final String JSON_MIME_TYPE = "application/json";
    private static final Status RESP_STATUS_OK = Status.lookup(200);
    private static final Status RESP_STATUS_BAD_METHOD = Status.lookup(405);
    private static final Status RESP_STATUS_NOT_ACCEPTABLE = Status.lookup(406);
    private static final int DRIVER_RESP_OKAY = 0;

private static String genException(int code, String desc) {
    try {
        JSONObject obj = new JSONObject();
        obj.put("status", code);
        obj.put("message", desc);
        Log.d(TAG,"------thread:"+Thread.currentThread().getId()+"-------Response:"+obj.toString());
        return obj.toString();
    }
    catch (JSONException e) {
        return null;
    }
}

public static Response wrongMethodResponse(String customizedDesc) {
    return Response.newFixedLengthResponse(
            DriverResponse.RESP_STATUS_BAD_METHOD,
            DriverResponse.JSON_MIME_TYPE,
            genException(DriverResponse.RESP_STATUS_BAD_METHOD.getRequestStatus(),
                    customizedDesc));
}

public static Response jsonExceptionResponse() {
    return Response.newFixedLengthResponse(
            DriverResponse.RESP_STATUS_NOT_ACCEPTABLE,
            DriverResponse.JSON_MIME_TYPE,
            genException(2, "json parsing exception"));
}

public static Response customizedResponse(int code, JSONObject obj) {
    JSONObject resp = new JSONObject();
    try {
        resp.put("status", code);
        if (obj == null)
            resp.put("data", "null");
        else
            resp.put("data", obj);
    }
    catch (Exception e) {
        e.printStackTrace();
    }
    //Log.d(TAG,"-------------Response:"+obj.toString());
    return Response.newFixedLengthResponse(
            DriverResponse.RESP_STATUS_OK, DriverResponse.JSON_MIME_TYPE, resp.toString());
}

public static Response okResponse(JSONObject json) {
    JSONObject obj = new JSONObject();
    try {
        obj.put("status", DRIVER_RESP_OKAY);
        obj.put("data", json);
    }
    catch (Exception e) {
        e.printStackTrace();
    }
    Log.d(TAG,"------thread:"+Thread.currentThread().getId()+"-------Response:"+obj.toString());
    return Response.newFixedLengthResponse(
            DriverResponse.RESP_STATUS_OK,
            DriverResponse.JSON_MIME_TYPE,
            obj.toString());
}

public static final Response okResponse(JSONArray array) {
    JSONObject obj = new JSONObject();
    try {
        obj.put("status", DRIVER_RESP_OKAY);
        obj.put("data", array);
    }
    catch (Exception e) {
        e.printStackTrace();
    }
    Log.d(TAG,"------thread:"+Thread.currentThread().getId()+"-------Response:"+obj.toString());
    return Response.newFixedLengthResponse(
            DriverResponse.RESP_STATUS_OK,
            DriverResponse.JSON_MIME_TYPE,
            obj.toString());
}

public static Response wrongContentTypeResponse() {
    return Response.newFixedLengthResponse(
            DriverResponse.RESP_STATUS_NOT_ACCEPTABLE,
            DriverResponse.JSON_MIME_TYPE,
            genException(DriverResponse.RESP_STATUS_NOT_ACCEPTABLE.getRequestStatus(),
                    null));
}
}