// -*- mode: java; c-basic-offset: 2; -*-

// Copyright 2009-2011 Google, All Rights reserved

// Copyright 2011-2012 MIT, All rights reserved
// Released under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0

package com.gmail.at.moicjarod;

import com.google.appinventor.components.runtime.*;
import com.google.appinventor.components.runtime.util.RuntimeErrorAlert;
import com.google.appinventor.components.annotations.DesignerComponent;
import com.google.appinventor.components.annotations.DesignerProperty;
import com.google.appinventor.components.annotations.PropertyCategory;
import com.google.appinventor.components.annotations.SimpleEvent;
import com.google.appinventor.components.annotations.SimpleFunction;
import com.google.appinventor.components.annotations.SimpleObject;
import com.google.appinventor.components.annotations.SimpleProperty;
import com.google.appinventor.components.annotations.UsesLibraries;
import com.google.appinventor.components.annotations.UsesPermissions;
import com.google.appinventor.components.common.ComponentCategory;
import com.google.appinventor.components.common.PropertyTypeConstants;
import com.google.appinventor.components.runtime.util.AsynchUtil;
import com.google.appinventor.components.runtime.util.ErrorMessages;
import com.google.appinventor.components.runtime.util.YailList;
import com.google.appinventor.components.runtime.util.SdkLevel;

import com.google.appinventor.components.runtime.errors.YailRuntimeError;

import android.app.Activity;
import android.text.TextUtils;
import android.util.Log;
import android.os.StrictMode;

import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.InetSocketAddress;
import java.net.SocketException;

/**
* Simple Client Socket
* @author [email protected] (Jean-Rodolphe Letertre)
* with the help of the work of lizlooney @ google.com (Liz Looney) and
josmasflores @ gmail.com (Jose Dominguez)
* the help of Alexey Brylevskiy for debugging
* and the help of Hossein Amerkashi from AppyBuilder for compatibility with
AppyBuilder
*/
@DesignerComponent(version = 4,
description = "Non-visible component that provides client socket connectivity.",
category = ComponentCategory.EXTENSION,
nonVisible = true,
iconName = "http://jr.letertre.free.fr/Projets/AIClientSocket/clientsocket.png")
@SimpleObject(external = true)
@UsesPermissions(permissionNames = "android.permission.INTERNET")
public class ClientSocketAI2Ext extends AndroidNonvisibleComponent implements
Component
{
private static final String LOG_TAG = "ClientSocketAI2Ext";

private final Activity activity;

// the socket object

private Socket clientSocket = null;
// the address to connect to
private String serverAddress = "";
// the port to connect to
private String serverPort = "";
// connection timeout to server in ms
private int timeoutms = 2000;
// boolean that indicates the state of the connection, true = connected, false =
not connected
private boolean connectionState = false;
// boolean that indicates the mode used, false = string sent as is, true = String
is considered as hexadecimal data and will be converted before sending
// same behavior is used when receiving data
private boolean hexaStringMode = false;
// boolean to enable debug messages "YailRuntimeError" (true by default to ensure
same behavior as before)
private boolean debugMessages = true;

InputStream inputStream = null;

/**
* Creates a new Client Socket component.
*
* @param container the Form that this component is contained in.
*/
public ClientSocketAI2Ext(ComponentContainer container)
{
super(container.$form());
activity = container.$context();
// compatibility with AppyBuilder (thx Hossein Amerkashi <kkashi01 [at] gmail
[dot] com>)
StrictMode.ThreadPolicy policy = new
StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(policy);
}

/**
* Method that returns the server's address.
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "The address
of the server the client will connect to.")
public String ServerAddress()
{
return serverAddress;
}

/**
* Method to specify the server's address
*/
@DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_STRING)
@SimpleProperty
 public void ServerAddress(String address)
{
serverAddress = address;
}

/**
* Method that returns the server's port.
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "The port of
the server the client will connect to.")
public String ServerPort()
{
return serverPort;
}

/**
* Method to specify the server's port
*/
@DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_STRING)
@SimpleProperty
public void ServerPort(String port)
{
serverPort = port;
}

/**
* Method that returns the timeout to server in ms
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "The timeout
to server in ms")
public int TimeoutMs()
{
return timeoutms;
}

/**
* Method to specify the timeout to server in ms
*/
@DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_INTEGER,
defaultValue="2000")
@SimpleProperty
public void TimeoutMs(int timeout)
{
timeoutms = timeout;
}

/**
* Method that returns the connection state
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "The state of
the connection - true = connected, false = disconnected")
public boolean ConnectionState()
{
return connectionState;
}

/**
* Method that returns a string containing "\n\r" sequence
*/
 @SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "returns a
string containing \"\n\r\" sequence")
public String SeqNewLineAndRet()
{
String seq = "";
seq = seq + '\n' + '\r';
return seq;
}

/**
* Method that returns a string containing "\r\n" sequence
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "returns a
string containing \"\r\n\" sequence")
public String SeqRetAndNewLine()
{
String seq = "";
seq = seq + '\r' + '\n';
return seq;
}

/**
* Method that returns a string containing "\r" sequence
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "returns a
string containing \"\r\" sequence")
public String SeqRet()
{
String seq = "";
seq = seq + '\r';
return seq;
}

/**
* Method that returns a string containing "\n" sequence
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "returns a
string containing \"\n\" sequence")
public String SeqNewLine()
{
String seq = "";
seq = seq + '\n';
return seq;
}

/**
* Method that returns the mode (string or hexastring)
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "The mode of
sending and receiving data.")
public boolean HexaStringMode()
{
return hexaStringMode;
}

/**
* Method to specify the mode (string or hexastring)
*/
@DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN)
 @SimpleProperty
public void HexaStringMode(boolean mode)
{
hexaStringMode = mode;
}

/**
* Method that returns the display of debug messages
*/
@SimpleProperty(category = PropertyCategory.BEHAVIOR, description = "The display
of debug messages.")
public boolean DebugMessages()
{
return debugMessages;
}

/**
* Method to specify the display of debug messages
*/
@DesignerProperty(editorType = PropertyTypeConstants.PROPERTY_TYPE_BOOLEAN,
defaultValue="True")
@SimpleProperty
public void DebugMessages(boolean displayDebugMessages)
{
debugMessages = displayDebugMessages;
}

/**
* Creates the socket, connect to the server and launches the thread to receive
data from server
*/
@SimpleFunction(description = "Tries to connect to the server and launches the
thread for receiving data (blocking until connected or failed)")
public void Connect()
{
if (connectionState == true)
{
if (debugMessages == true)
throw new YailRuntimeError("Connect error, socket connected yet, please
disconnect before reconnect !", "Error");
}
try
{
// connecting the socket
clientSocket = new Socket();
clientSocket.connect(new InetSocketAddress(serverAddress,
Integer.parseInt(serverPort)), timeoutms);
connectionState = true;
// begin the receive loop in a new thread
AsynchUtil.runAsynchronously(new Runnable()
{
@Override
public void run()
{
ByteArrayOutputStream byteArrayOutputStream = new
ByteArrayOutputStream(1024);
byte[] buffer = new byte[1024];
int bytesRead = 0;
 try
{
// get the input stream and save the data
inputStream = clientSocket.getInputStream();
while (true)
{
// test if there is a server problem then close socket properly (thx
Axeley :-))
try
{
bytesRead = inputStream.read(buffer);
if(bytesRead == -1)
break;
}
catch(SocketException e)
{
//throw e;
}
catch(IOException e)
{
if(e.getMessage().indexOf("ETIMEDOUT") >= 0)
break;
//throw e;
}

byteArrayOutputStream.write(buffer, 0, bytesRead);
final String dataReceived;
// hexaStringMode is false, so we don't transform the string received
if (hexaStringMode == false)
{
dataReceived = byteArrayOutputStream.toString("UTF-8");
}
// hexaStringMode is true, so we make a string with each character as
an hexa symbol representing the received message
else
{
int i;
char hexaSymbol1, hexaSymbol2;
String tempData = "";
byte[] byteArray = byteArrayOutputStream.toByteArray();
for (i = 0; i < byteArrayOutputStream.size(); i++)
{
if (((byteArray[i] & 0xF0) >> 4) < 0xA)
// 0 to 9 symbol
hexaSymbol1 = (char)(((byteArray[i] & 0xF0) >> 4) + 0x30);
else
// A to F symbol
hexaSymbol1 = (char)(((byteArray[i] & 0xF0) >> 4) + 0x37);
if ((byteArray[i] & 0x0F) < 0xA)
hexaSymbol2 = (char)((byteArray[i] & 0x0F) + 0x30);
else
hexaSymbol2 = (char)((byteArray[i] & 0x0F) + 0x37);
tempData = tempData + hexaSymbol1 + hexaSymbol2;
}

dataReceived = tempData;
}
// reset of the byteArrayOutputStream to flush the content
byteArrayOutputStream.reset();
 // then we send the data to the user using an event
// events must be sent by the main thread (UI)
activity.runOnUiThread(new Runnable()
{
@Override
public void run()
{
DataReceived(dataReceived);
}
} );
}
// When we go there, either we have
// - server shutdown
// - disconnection asked (inputstream closed => -1 returned)
// - connection problem
// so, if it is not disconnected yet, we disconnect the socket and
inform the user of it.
if (connectionState == true)
{
Disconnect();
// events must be sent by the main thread (UI)
activity.runOnUiThread(new Runnable()
{
@Override
public void run()
{
RemoteConnectionClosed();
}
} );
}
}
catch (SocketException e)
{
Log.e(LOG_TAG, "ERROR_READ", e);
if (debugMessages == true)
throw new YailRuntimeError("Connect error (read 1) " +
e.getMessage(), "Error");
}
catch (IOException e)
{
Log.e(LOG_TAG, "ERROR_READ", e);
if (debugMessages == true)
throw new YailRuntimeError("Connect error (read 2)", "Error");
}
catch (Exception e)
{
connectionState = false;
Log.e(LOG_TAG, "ERROR_READ", e);
if (debugMessages == true)
throw new YailRuntimeError("Connect error (read 3) " +
e.getMessage(), "Error");
}
}
} );
}
catch (SocketException e)
{
Log.e(LOG_TAG, "ERROR_CONNECT", e);
if (debugMessages == true)
 throw new YailRuntimeError("Connect error" + e.getMessage(), "Error");
}
catch (Exception e)
{
connectionState = false;
Log.e(LOG_TAG, "ERROR_CONNECT", e);
if (debugMessages == true)
throw new YailRuntimeError("Connect error (Socket Creation, please check Ip
or hostname -> )" + e.getMessage(), "Error");
}
}

/**
* Send data through the socket to the server
*/
@SimpleFunction(description = "Send data to the server")
public void SendData(final String data)
{
if (connectionState == false)
{
if (debugMessages == true)
throw new YailRuntimeError("Send error, socket not connected.", "Error");
}
final byte [] dataToSend;
byte [] dataCopy = data.getBytes();
if (hexaStringMode == false)
{
//dataSend = new byte [data.length()];
// if hexaStringMode is false, we send data as is
dataToSend = dataCopy;
}
else
{
// if hexaStringMode is true, we begin to verify we can transcode the symbols
// verify if the data we want to send contains only hexa symbols
int i;
for (i = 0; i < data.length(); i++)
{
if (((dataCopy[i] < 0x30) || (dataCopy[i] > 0x39)) && ((dataCopy[i] < 0x41)
|| (dataCopy[i] > 0x46)) && ((dataCopy[i] < 0x61) || (dataCopy[i] > 0x66)))
if (debugMessages == true)
throw new YailRuntimeError("Send data : hexaStringMode is selected and
non hexa symbol found in send String.", "Error");
}
// verify that the number of symbols is even
if ((data.length() %2) == 1)
{
if (debugMessages == true)
throw new YailRuntimeError("Send data : hexaStringMode is selected and
send String length is odd. Even number of characters needed.", "Error");
}
// if all tests pass, we transcode the data :
dataToSend=new byte[data.length()/2];
for (i = 0; i < data.length(); i=i+2)
{
byte [] temp1 = new byte [2];
temp1 [0] = dataCopy[i];
temp1 [1] = dataCopy[i+1];
String temp2 = new String (temp1);
 dataToSend[i/2]=(byte)Integer.parseInt(temp2, 16);
}
// those two lines were removed because of a bug sending trailing 0x00 in
hexaString mode
// if 0x00 is really needed, we should add it directly in the string we
want to send
// end of c-type string character
// dataToSend[i/2] = (byte)0x00;
}

// we then send asynchonously the data

AsynchUtil.runAsynchronously(new Runnable()
{
@Override
public void run()
{
try
{
OutputStream out;
out = clientSocket.getOutputStream();
out.write(dataToSend);
}
catch (SocketException e)
{
Log.e(LOG_TAG, "ERROR_SEND", e);
if (debugMessages == true)
throw new YailRuntimeError("Send data" + e.getMessage(), "Error");
}
catch (Exception e)
{
Log.e(LOG_TAG, "ERROR_UNABLE_TO_SEND_DATA", e);
if (debugMessages == true)
throw new YailRuntimeError("Send Data", "Error");
}
}
} );
}

/**
* Close the socket
*/
@SimpleFunction(description = "Disconnect to the server")
public void Disconnect()
{
if (connectionState == true)
{
connectionState = false;
try
{
// shutdown the input socket,
//clientSocket.shutdownInput();
//clientSocket.shutdownOutput();
clientSocket.close();
}
catch (SocketException e)
{
// modifications by axeley too :-)
if(e.getMessage().indexOf("ENOTCONN") == -1)
{
 Log.e(LOG_TAG, "ERROR_CONNECT", e);
if (debugMessages == true)
throw new YailRuntimeError("Disconnect" + e.getMessage(), "Error");
}
// if not connected, then just ignore the exception
}
catch (IOException e)
{
Log.e(LOG_TAG, "ERROR_CONNECT", e);
if (debugMessages == true)
throw new YailRuntimeError("Disconnect" + e.getMessage(), "Error");
}
catch (Exception e)
{
Log.e(LOG_TAG, "ERROR_CONNECT", e);
if (debugMessages == true)
throw new YailRuntimeError("Disconnect" + e.getMessage(), "Error");
}
finally
{
clientSocket=null;
}

}
else
if (debugMessages == true)
throw new YailRuntimeError("Socket not connected, can't disconnect.",
"Error");
}

/**
* Event indicating that a message has been received
*
* @param data the data sent by the server
*/
@SimpleEvent
public void DataReceived(String data)
{
// invoke the application's "DataReceived" event handler.
EventDispatcher.dispatchEvent(this, "DataReceived", data);
}

/**
* Event indicating that the remote socket closed the connection
*
*/
@SimpleEvent
public void RemoteConnectionClosed()
{
// invoke the application's "RemoteConnectionClosed" event handler.
EventDispatcher.dispatchEvent(this, "RemoteConnectionClosed");
}
}