BufferedAsyncSerial.cpp

/*
 * File:   BufferedAsyncSerial.cpp
 * Author: Terraneo Federico
 * Distributed under the Boost Software License, Version 1.0.
 * Created on January 6, 2011, 3:31 PM
 */
 
#include "BufferedAsyncSerial.h"
#include "plugin.h"
 
#include <string>
#include <algorithm>
#include <iostream>
#include <boost/bind/bind.hpp>
 
using namespace std;
using namespace boost;
 
//
//Class BufferedAsyncSerial
//
 
#ifndef ANDROID
BufferedAsyncSerial::BufferedAsyncSerial() : AsyncSerial()
{
  setReadCallback(boost::bind(&BufferedAsyncSerial::readCallback, this, boost::placeholders::_1, boost::placeholders::_2));
}
 
BufferedAsyncSerial::BufferedAsyncSerial(const std::string& devname,
  unsigned int baud_rate,
  asio::serial_port_base::parity opt_parity,
  asio::serial_port_base::character_size opt_csize,
  asio::serial_port_base::flow_control opt_flow,
  asio::serial_port_base::stop_bits opt_stop)
  : AsyncSerial(devname, baud_rate, opt_parity, opt_csize, opt_flow, opt_stop)
{
  setReadCallback(boost::bind(&BufferedAsyncSerial::readCallback, this, boost::placeholders::_1, boost::placeholders::_2));
}
 
size_t BufferedAsyncSerial::read(char *data, size_t size)
{
  boost::lock_guard<boost::mutex> l(readQueueMutex);
  size_t result = min(size, readQueue.size());
  vector<char>::iterator it = readQueue.begin() + result;
  copy(readQueue.begin(), it, data);
  readQueue.erase(readQueue.begin(), it);
  return result;
}
 
std::vector<char> BufferedAsyncSerial::read()
{
  boost::lock_guard<boost::mutex> l(readQueueMutex);
  vector<char> result;
  result.swap(readQueue);
  return result;
}
 
std::string BufferedAsyncSerial::readString()
{
  boost::lock_guard<boost::mutex> l(readQueueMutex);
  string result(readQueue.begin(), readQueue.end());
  readQueue.clear();
  return result;
}
 
std::string BufferedAsyncSerial::readStringUntil(const std::string delim)
{
  boost::lock_guard<boost::mutex> l(readQueueMutex);
  vector<char>::iterator it = findStringInVector(readQueue, delim);
  if (it == readQueue.end()) return "";
  string result(readQueue.begin(), it);
  it += delim.size();//Do remove the delimiter from the queue
  readQueue.erase(readQueue.begin(), it);
  return result;
}
 
void BufferedAsyncSerial::readCallback(const char *data, size_t len)
{
  boost::lock_guard<boost::mutex> l(readQueueMutex);
  readQueue.insert(readQueue.end(), data, data + len);
 
  //read callback
  std::string* buffer = new std::string(readQueue.begin(), readQueue.end());
  OBJpostEvent(SERIAL_READ_CB, SCOL_PTR this, SCOL_PTR buffer);
  readQueue.clear();
}
 
std::vector<char>::iterator BufferedAsyncSerial::findStringInVector(
  std::vector<char>& v, const std::string& s)
{
  if (s.size() == 0) return v.end();
 
  vector<char>::iterator it = v.begin();
  for (;;)
  {
    vector<char>::iterator result = find(it, v.end(), s[0]);
    if (result == v.end()) return v.end();//If not found return
 
    for (size_t i = 0; i < s.size(); i++)
    {
      vector<char>::iterator temp = result + i;
      if (temp == v.end()) return v.end();
      if (s[i] != *temp) goto mismatch;
    }
    //Found
    return result;
 
  mismatch:
    it = result + 1;
  }
}
 
BufferedAsyncSerial::~BufferedAsyncSerial()
{
  clearReadCallback();
}
#else
BufferedAsyncSerial::BufferedAsyncSerial()
{
  mPort = "0";
  mConnected = false;
  mEnable = true;
  mThread = boost::thread(boost::bind(&BufferedAsyncSerial::cbThread, this));
}
 
BufferedAsyncSerial::BufferedAsyncSerial(const std::string& devname)
{
  mPort = devname;
  mConnected = false;
  mEnable = true;
  mThread = boost::thread(boost::bind(&BufferedAsyncSerial::cbThread, this));
}
 
BufferedAsyncSerial::~BufferedAsyncSerial()
{
  mEnable = false;
  if (mThread.joinable())
    mThread.join();
 
  disconnect();
}
 
bool BufferedAsyncSerial::connect()
{
  JNIEnv* env = 0;
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  androidApp->activity->vm->AttachCurrentThread(&env, NULL);
 
  // Get class
  jobject oActivity = androidApp->activity->clazz;
  jclass cActivity = env->GetObjectClass(oActivity);
  if (cActivity)
  {
    jobject scolexternal_object = 0;
    jclass scolexternal_clazz = 0;
    jmethodID jHaveBluetooth = 0;
 
    jfieldID scolexternal_fieldID = env->GetFieldID(cActivity, "mScolExternal", "Lorg/imaginer/scol/ScolExternal;");
    if (scolexternal_fieldID)
      scolexternal_object = env->GetObjectField(oActivity, scolexternal_fieldID);
    if (scolexternal_object)
      scolexternal_clazz = env->GetObjectClass(scolexternal_object);
    if (scolexternal_clazz)
      jHaveBluetooth = env->GetMethodID(scolexternal_clazz, "haveBluetooth", "()Z");
 
    if (!jHaveBluetooth)
    {
      //LOGI("Error : haveBluetooth not found");
      env->DeleteLocalRef(cActivity);
      androidApp->activity->vm->DetachCurrentThread();
      return false;
    }
    bool havebt = (bool)env->CallBooleanMethod(scolexternal_object, jHaveBluetooth);
 
    if (!havebt)
    {
      if (env->ExceptionCheck())
      {
        env->ExceptionClear();
        MMechostr(MSKRUNTIME, "Android bluetooth exception : Check android.permission.BLUETOOTH\n");
      }
 
      // Release references
      env->DeleteLocalRef(scolexternal_object);
      env->DeleteLocalRef(cActivity);
      androidApp->activity->vm->DetachCurrentThread();
      return false;
    }
    jmethodID jConnectBluetooth = env->GetMethodID(scolexternal_clazz, "connectBluetooth", "(Ljava/lang/String;)Z");
 
    if (!jConnectBluetooth)
    {
      // Release references
      env->DeleteLocalRef(scolexternal_clazz);
      env->DeleteLocalRef(scolexternal_object);
      env->DeleteLocalRef(cActivity);
      androidApp->activity->vm->DetachCurrentThread();
      return false;
    }
 
    jstring address = env->NewStringUTF(mPort.c_str());
    mConnected = (bool)env->CallBooleanMethod(scolexternal_object, jConnectBluetooth, address);
 
    if (env->ExceptionCheck())
    {
      env->ExceptionClear();
      MMechostr(MSKRUNTIME, "Android bluetooth exception : Could not connect to device.\n");
    }
 
    // Release references
    env->DeleteLocalRef(address);
    env->DeleteLocalRef(scolexternal_clazz);
    env->DeleteLocalRef(scolexternal_object);
    env->DeleteLocalRef(cActivity);
  }
 
  androidApp->activity->vm->DetachCurrentThread();
  return mConnected;
}
 
void BufferedAsyncSerial::disconnect()
{
  JNIEnv* env = 0;
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  androidApp->activity->vm->AttachCurrentThread(&env, NULL);
 
  // Get class
  jobject oActivity = androidApp->activity->clazz;
  jclass cActivity = env->GetObjectClass(oActivity);
  if (cActivity)
  {
    jobject scolexternal_object = 0;
    jclass scolexternal_clazz = 0;
    jmethodID jDisconnectBluetooth = 0;
 
    jfieldID scolexternal_fieldID = env->GetFieldID(cActivity, "mScolExternal", "Lorg/imaginer/scol/ScolExternal;");
    if (scolexternal_fieldID)
      scolexternal_object = env->GetObjectField(oActivity, scolexternal_fieldID);
    if (scolexternal_object)
      scolexternal_clazz = env->GetObjectClass(scolexternal_object);
    if (scolexternal_clazz)
      jDisconnectBluetooth = env->GetMethodID(scolexternal_clazz, "disconnectBluetooth", "()V");
    if (jDisconnectBluetooth)
      env->CallVoidMethod(scolexternal_object, jDisconnectBluetooth);
 
    if (env->ExceptionCheck())
    {
      env->ExceptionClear();
      MMechostr(MSKRUNTIME, "Android bluetooth exception : could not disconnect from device.\n");
    }
 
    // Release references
    env->DeleteLocalRef(scolexternal_clazz);
    env->DeleteLocalRef(scolexternal_object);
    env->DeleteLocalRef(cActivity);
  }
 
  androidApp->activity->vm->DetachCurrentThread();
}
 
void BufferedAsyncSerial::cbThread()
{
  while (mEnable)
  {
    if (!mConnected)
      connect();
 
    //still not conencted wait a bit more
    if (!mConnected)
      boost::this_thread::sleep_for(boost::chrono::milliseconds(1000));
    else
      readData();
 
    boost::this_thread::sleep_for(boost::chrono::milliseconds(16));
  }
}
 
void BufferedAsyncSerial::readData()
{
  JNIEnv* env = 0;
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  androidApp->activity->vm->AttachCurrentThread(&env, NULL);
 
  // Get class
  jobject oActivity = androidApp->activity->clazz;
  jclass cActivity = env->GetObjectClass(oActivity);
  if (cActivity)
  {
    jobject scolexternal_object = 0;
    jclass scolexternal_clazz = 0;
    jmethodID jReadBluetooth = 0;
 
    jfieldID scolexternal_fieldID = env->GetFieldID(cActivity, "mScolExternal", "Lorg/imaginer/scol/ScolExternal;");
    if (scolexternal_fieldID)
      scolexternal_object = env->GetObjectField(oActivity, scolexternal_fieldID);
    if (scolexternal_object)
      scolexternal_clazz = env->GetObjectClass(scolexternal_object);
    if (scolexternal_clazz)
      jReadBluetooth = env->GetMethodID(scolexternal_clazz, "getBluetoothData", "()[B");
 
    if (!jReadBluetooth)
    {
      //LOGI("Error : haveBluetooth not found");
      env->DeleteLocalRef(cActivity);
      androidApp->activity->vm->DetachCurrentThread();
      return;
    }
 
    jbyteArray jarray = (jbyteArray)env->CallObjectMethod(scolexternal_object, jReadBluetooth);
    if (jarray != NULL)
    {
      jboolean isCopy;
      jsize lenght = env->GetArrayLength(jarray);
      jbyte* data = env->GetByteArrayElements(jarray, &isCopy);
      if (env->ExceptionCheck())
      {
        env->ExceptionClear();
        env->DeleteLocalRef(jarray);
        env->DeleteLocalRef(scolexternal_object);
        env->DeleteLocalRef(cActivity);
        androidApp->activity->vm->DetachCurrentThread();
        return;
      }
 
      if (lenght > 0)
      {
        char* sdata = (char*)malloc(lenght);
        memcpy(sdata, (char*)data, lenght);
 
        //send to scol callback
        std::string* buffer = new std::string(sdata, lenght);
        OBJpostEvent(SERIAL_READ_CB, SCOL_PTR this, SCOL_PTR buffer);
 
        free(sdata);
      }
 
      if (data != NULL)
        env->ReleaseByteArrayElements(jarray, data, 0);
 
      if (env->ExceptionCheck())
      {
        env->ExceptionClear();
        env->DeleteLocalRef(jarray);
        env->DeleteLocalRef(scolexternal_object);
        env->DeleteLocalRef(cActivity);
        androidApp->activity->vm->DetachCurrentThread();
        return;
      }
      env->DeleteLocalRef(jarray);
    }
    
    // Release references
    env->DeleteLocalRef(scolexternal_object);
    env->DeleteLocalRef(cActivity);
  }
 
  androidApp->activity->vm->DetachCurrentThread();
}
 
void BufferedAsyncSerial::writeString(const std::string& s)
{
  JNIEnv* env = 0;
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  androidApp->activity->vm->AttachCurrentThread(&env, NULL);
 
  // Get class
  jobject oActivity = androidApp->activity->clazz;
  jclass cActivity = env->GetObjectClass(oActivity);
  if (cActivity)
  {
    jobject scolexternal_object = 0;
    jclass scolexternal_clazz = 0;
    jmethodID jWriteBluetooth = 0;
 
    jfieldID scolexternal_fieldID = env->GetFieldID(cActivity, "mScolExternal", "Lorg/imaginer/scol/ScolExternal;");
    if (scolexternal_fieldID)
      scolexternal_object = env->GetObjectField(oActivity, scolexternal_fieldID);
    if (scolexternal_object)
      scolexternal_clazz = env->GetObjectClass(scolexternal_object);
    if (scolexternal_clazz)
      jWriteBluetooth = env->GetMethodID(scolexternal_clazz, "writeBluetoothData", "([B)Z");
 
    if (!jWriteBluetooth)
    {
      //LOGI("Error : haveBluetooth not found");
      env->DeleteLocalRef(cActivity);
      androidApp->activity->vm->DetachCurrentThread();
      return;
    }
 
    char* sdata = (char*)malloc(s.size());
    memcpy(sdata, s.data(), s.size());
    int dataSize = s.size();
 
    jbyteArray jdata = env->NewByteArray(dataSize);
    env->SetByteArrayRegion(jdata, 0, dataSize, (jbyte *)sdata);
 
    bool result = (bool)env->CallBooleanMethod(scolexternal_object, jWriteBluetooth, jdata);
    jboolean isCopy;
    if (jdata != NULL)
    {
      env->ReleaseByteArrayElements(jdata, (jbyte *)sdata, JNI_COMMIT);
 
      if (env->ExceptionCheck())
      {
        env->ExceptionClear();
        env->DeleteLocalRef(jdata);
        env->DeleteLocalRef(scolexternal_object);
        env->DeleteLocalRef(cActivity);
        free(sdata);
 
        if (!result)
          mConnected = false;
 
        androidApp->activity->vm->DetachCurrentThread();
        return;
      }
    }
 
    // Release references
    env->DeleteLocalRef(jdata);
    env->DeleteLocalRef(scolexternal_object);
    env->DeleteLocalRef(cActivity);
    free(sdata);
 
    //error disconnected
    if (!result)
      mConnected = false;
  }
 
  androidApp->activity->vm->DetachCurrentThread();
}
 
#endif