public class MainActivity extends Activity implements WebSocketListener {

    private static final String SLACK_RTM_URL = "https://slack.com/api/rtm.start";
    private static final String TAG = MainActivity.class.getSimpleName();
    private static final String TOKEN = "...";

    private final Executor writeExecutor = Executors.newSingleThreadExecutor();

    WebSocket mWebSocket = null;

    String url = "";

    int socket_id = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mHandler = new Handler();
        VolleyHelper.init(this);
        getRtmResponse(TOKEN);

        if (savedInstanceState == null) {
            getFragmentManager().beginTransaction()
                    .add(R.id.container, new PlaceholderFragment())
                    .commit();
        }
    }

    public void initSocket() {
        OkHttpClient client = new OkHttpClient();

        Request request = new Request.Builder()
                .url(url)
                .build();
        WebSocketCall.create(client, request).enqueue(this);

        // Trigger shutdown of the dispatcher's executor so this process can exit cleanly.
        client.getDispatcher().getExecutorService().shutdown();
    }

    public void sendMessage(View view) {
        EditText editText = (EditText) findViewById(R.id.message);
        final String msg = editText.getText().toString();
        writeExecutor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    JSONObject msgJson = new JSONObject();
                    try {
                        msgJson.put("id", ++socket_id);
                        msgJson.put("type", "message");
                        msgJson.put("channel", "C07V5R9U6");
                        msgJson.put("text", msg);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    mWebSocket.sendMessage(TEXT, new Buffer().writeUtf8(msgJson.toString()));
                } catch (IOException e) {
                    System.err.println("Unable to send messages: " + e.getMessage());
                }
            }
        });
        editText.setText("");
    }

    @Override
    public void onOpen(final WebSocket webSocket, Response response) {
        writeExecutor.execute(new Runnable() {
            @Override
            public void run() {
                mWebSocket = webSocket;
            }
        });
    }

    @Override
    public void onFailure(IOException e, Response response) {
        e.printStackTrace();
    }

    @Override
    public void onMessage(final BufferedSource payload, WebSocket.
            PayloadType type) throws IOException {
        switch (type) {
            case TEXT: {
                final String message = payload.readUtf8();
                System.out.println("MESSAGE: " + message);

                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        TextView textView = (TextView) findViewById(R.id.messages);
                        textView.setText(textView.getText() + "\n" + message);
                        Log.i("jhjhkhkj", message);
                    }
                });
            }
            break;
            case BINARY: {
                final String message = payload.readByteString().hex();
                System.out.println("MESSAGE: " + message);

                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        TextView textView = (TextView) findViewById(R.id.messages);
                        textView.setText(textView.getText() + "\n" + message);
                    }
                });
            }
            break;
            default:
                throw new IllegalStateException("Unknown payload type: " + type);
        }
        payload.close();
    }

    @Override
    public void onPong(Buffer payload) {
        Log.d(TAG, "PONG: " + payload.readUtf8());
    }

    @Override
    public void onClose(int code, String reason) {
        Log.d(TAG, "CLOSE: " + code + " " + reason);
    }

    void getRtmResponse(String token) {
        RequestQueue queue = VolleyHelper.getRequestQueue();
        JSONObject reqParams = null;
        final String transmitUrl = SLACK_RTM_URL + "?token=" + token;
        JsonObjectRequest staticDataReq = new JsonObjectRequest(com.android.volley.Request.Method.GET,
                transmitUrl, reqParams,
                getTransactionByIdSuccessListener(),
                getTransactionByIdErrorListener()) {
        };

        queue.add(staticDataReq);
    }

    private com.android.volley.Response.Listener<JSONObject> getTransactionByIdSuccessListener() {
        return new com.android.volley.Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                Log.i(TAG, "getTransactionByIdSuccessListener response" + response);
                try {
                    url = response.getString("url");
                    initSocket();
                    Log.i(TAG, "Url -" + response.getString("url"));
                } catch (Exception e) {
                    Log.e(TAG, "getTransactionByIdSuccessListener Could not parse malformed JSON: \"" + response + "\"");
                    e.printStackTrace();
                }
            }
        };
    }

    private com.android.volley.Response.ErrorListener getTransactionByIdErrorListener() {
        return new com.android.volley.Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.i(TAG, "Error" + error.getMessage());
            }
        };
    }

    private Handler mHandler;

    Runnable mStatusChecker = new Runnable() {
        @Override
        public void run() {
            ping();
            int interval = 3000;
            mHandler.postDelayed(mStatusChecker, interval);
        }
    };

    public void ping() {
        writeExecutor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    JSONObject msgJson = new JSONObject();
                    try {
                        msgJson.put("id", ++socket_id);
                        msgJson.put("type", "ping");
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    mWebSocket.sendMessage(TEXT, new Buffer().writeUtf8(msgJson.toString()));
                } catch (IOException e) {
                    System.err.println("Unable to send messages: " + e.getMessage());
                }
            }
        });

    }
}