File content as of revision 1:b49a6e72f353:

#include "JAudioStream.h"

JAudioStream::JAudioStream() {
    connected = false;
    inTransmission = false;
}

void JAudioStream::begin(char* mac, char* ip, short port) {
    eth.init();
    eth.connect();
    udp.init();
    udp.set_blocking(true);
}

bool JAudioStream::connect(char* ip, short port, char* name) {
    remotePort = port;
    remoteIp = ip;
    endPoint.set_address(ip, port);
    char size = MESSAGE_SIZE*2;
    char message[size];
    buildMeassge(cont, REQUEST_RESPONSE_MODE, name, message);
    send(message, size);
    char resp[MAX_PACKT];
    if (read(resp, MAX_PACKT, 500)) {
        if (memcmp(resp, cond, 4) == 0) {
            connected = true;
        }
    }
    return connected;
}

bool JAudioStream::read(char *buffer, short amount, short timeOut) {
    bool result = false;
    if (udp.receiveFrom(endPoint,buffer, MAX_PACKT) > 0) {
        result = true;        
    }
    return result;
}

bool JAudioStream::available() {
    if (inTransmission) {
        return true;
    } else {
        char resp[MAX_PACKT];
        if (read(resp, MAX_PACKT, 500)) {
            if (memcmp(resp, begn, 4) == 0) {
                memmove(&nowPlaying[0], &resp[4], 20);
                inTransmission = true;
                return true;
            }
        }
    }
    return false;
}

bool JAudioStream::isConnected() {
    return connected;
}

void JAudioStream::request(char amount) {
    char message[MESSAGE_SIZE];
    buildMeassge(rqst, amount, message);
    send(message, MESSAGE_SIZE);
}

void JAudioStream::disconnect() {
    char message[MESSAGE_SIZE];
    buildMeassge(dcon, -1, message);
    send(message, MESSAGE_SIZE);
}

void JAudioStream::buildMeassge(const char* cmd, int param, char* message) {
    char i;
    for(i=0; i<MESSAGE_COMP_SIZE; i++) {
            message[i] = cmd[i];
    }
    char bParam[MESSAGE_COMP_SIZE];
    intTocharArr(param, bParam);
    for(i=MESSAGE_COMP_SIZE; i<MESSAGE_SIZE; i++) {
            message[i] = bParam[i-MESSAGE_COMP_SIZE];
    }
}

void JAudioStream::buildMeassge(const char* cmd, int param, char* data, char* message) {
    char i;
    for(i=0; i<MESSAGE_COMP_SIZE; i++) {
            message[i] = cmd[i];
    }
    char bParam[MESSAGE_COMP_SIZE];
    intTocharArr(param, bParam);
    for(i=MESSAGE_COMP_SIZE; i<MESSAGE_SIZE; i++) {
            message[i] = bParam[i-MESSAGE_COMP_SIZE];
    }
    char dataSize = MESSAGE_SIZE*2;
    for(i=MESSAGE_SIZE; i<dataSize; i++) {
        message[i] = data[i-MESSAGE_SIZE];
    }
}

void JAudioStream::intTocharArr(int value, char* buff) {
    buff[0] = (value >> 24) & 0xFF;
    buff[1] = (value >> 16) & 0xFF;
    buff[2] = (value >> 8) & 0xFF;
    buff[3] = value;
}

void JAudioStream::send(char* data, short len) {
    udp.sendTo(endPoint, data, len);
}

char* JAudioStream::getNowPlaying() {
    return nowPlaying;
}