native-app-windows

#include <stdio.h>
#include <iostream>
#include <string>
#include <math.h>
#include <stdlib.h>
#include "ScreenShare.h"
#include "Log.h"

#define MAX_SIZE 200

LOG_DECLARE;

enum Method_Name
{
    ENCODE_FRAME,
    ENCODE_FRAME_DIFFERENCE
};

std::string encode_Frame(ScreenShare&, long*, long*, int*);
std::string encode_Frame_Difference(ScreenShare&, long*, long*, int*);

void init_Logging();
std::string get_Message();
Method_Name parse_Message(std::string);

// Optional Parameters : data=> indexing/appshare | opt1=> width/mouseX | opt2=> height/mouseY | opt3=> appshareLength //
std::string make_final_JSON(Method_Name, char* data="", char* op1="", char* op2="", char* opt3="");

char* strip_CR(char*,int);
void send_Final_Message(std::string);

int main() {

    std::cout.setf( std::ios_base::unitbuf );

    init_Logging();

    ScreenShare ss;

    long mouseX, mouseY;
    int encodeLength, count=0;
    std::string input, final_json;

    do {
        input = get_Message();

        LOG_INFO((char*)input.c_str());

        Method_Name methodName = parse_Message(input);

        switch(methodName) {

            case ENCODE_FRAME: final_json = encode_Frame(ss, &mouseX, &mouseY, &encodeLength);
            break;

            case ENCODE_FRAME_DIFFERENCE: final_json = encode_Frame_Difference(ss, &mouseX, &mouseY, &encodeLength);
            break;

                       //default:  LOG_ERR("Invalid Method Name");

        }

        LOG_INFO("Sending final Json..");

        send_Final_Message(final_json);

    } while(1);

    return 0;

}//END_OF_MAIN
/////////////////////////////////////////////////////////////////////////////////////////

void send_Final_Message(std::string final_msg) {

        unsigned int len = final_msg.length();

        //Sending 4bytes of length information
         std::cout  << char(((len>>0) & 0xFF))
                    << char(((len>>8) & 0xFF))
                    << char(((len>>16) & 0xFF))
                    << char(((len>>24) & 0xFF));

        // Now we can output our message
        std::cout << final_msg;

        //fwrite(&len, 4, 1, stdout);  //Sending 4bytes of length information
        //fwrite(final_msg.c_str(), len, 1, stdout); // Now we can output our message

        final_msg.clear();
}

std::string make_final_JSON(Method_Name method, char* data, char* opt1, char* opt2, char* opt3) {

        std::string final_json;

        switch(method) {

            case ENCODE_FRAME: LOG_INFO("Make_FINAL_JSON:: ENCODE_FRAME ..");

                final_json.append("{\"result\":\"encodeFrame\", \"value\":");
                final_json.append("{\"mouseX\":\"");
                final_json.append(opt1);
                final_json.append("\",\"mouseY\":\"");
                    final_json.append(opt2);
                final_json.append("\",\"length\":\"");
                final_json.append(opt3);
                final_json.append("\",\"data\":\"");
                final_json.append(data);
            break;

            case ENCODE_FRAME_DIFFERENCE:LOG_INFO("Make_FINAL_JSON:: ENCODE_FRAME_DIFFERENCE ..");

                final_json.append("{\"result\":\"encodeFrameDifference\", \"value\":");
                final_json.append("{\"mouseX\":\"");
                final_json.append(opt1);
                final_json.append("\",\"mouseY\":\"");
                final_json.append(opt2);
                final_json.append("\",\"length\":\"");
                final_json.append(opt3);
                final_json.append("\",\"data\":\"");
                final_json.append(data);
                break;
        }

        final_json.append("\"}}");

        if(data != NULL) {
            delete data;
            data=NULL;
        }
        if(opt1!=NULL) { delete opt1; opt1=NULL; }
        if(opt2!=NULL) { delete opt2; opt2=NULL; }
        if(opt3!=NULL) { delete opt3; opt3=NULL; }

        return final_json;
}

Method_Name parse_Message(std::string msg) {

    Method_Name method  = ENCODE_FRAME_DIFFERENCE;

    if (msg.find("xencodeFrame") != std::string::npos) {
        method = ENCODE_FRAME;
    }
    else if (msg.find("encodeFrameDifference") != std::string::npos) {
        method = ENCODE_FRAME_DIFFERENCE;
    }
    return method;
}

std::string get_Message() {

    LOG_DEBUG("Getting message from extension.. ");

    unsigned int input_length=0, a, ch, length = 0;
    int i;
    input_length=0;
    std::string input;

        for (i = 0; i<= 3; i++) {
            input_length += pow(256.0f, i) *getchar();
        }

        for (a=0; a < input_length; a++) {
            ch = getchar();
            input += ch;
        }

        return input;
}

char* strip_CR(char *s, int len)
{
    char *p = new char[len+1];
    if(p) {
        char *p2 = p;
        while(*s != '\0') {
            if(*s != '\r' && *s != '\n') {
                *p2++ = *s++;
            } else {
                ++s;
            }
        }
        *p2 = '\0';
    }
    return p;
}

std::string encode_Frame(ScreenShare& ss,  long* mouseX, long* mouseY,
                                        int* encodedLength) {
        LOG_INFO("inside encode_Frame ... ");
        char sMouseX[10], sMouseY[10], bufferLength[10];
        unsigned int length = 0;

        unsigned char* data = ss.encodeFrame(
                                mouseX, mouseY, encodedLength);

        char* sNewTempEncodedData = ss.base64Encode(data, *encodedLength, &length);

        char* clean_data = strip_CR(sNewTempEncodedData, length);

        //Converting long/int to string
        sprintf( sMouseX, "%ld", *mouseX );
        sprintf( sMouseY, "%ld", *mouseY );
        sprintf( bufferLength, "%d", *encodedLength );

        LOG_DEBUG("E.F. Length we're sending...");
        LOG_DEBUG(bufferLength);

        return make_final_JSON(ENCODE_FRAME, clean_data, sMouseX, sMouseY, bufferLength);
}

std::string encode_Frame_Difference(ScreenShare& ss, long* mouseX, long* mouseY,
                                        int* encodedLength) {
        LOG_INFO("inside encode_Frame_Difference ... ");
        char sMouseX[10], sMouseY[10], bufferLength[10];
        unsigned int length = 0;

        unsigned char* data = ss.encodeFrameDifference(
                                mouseX, mouseY, encodedLength);

        char* sNewTempEncodedData = ss.base64Encode(data, *encodedLength, &length);

        char* clean_data = strip_CR(sNewTempEncodedData, length);

        //Converting long to string
        sprintf( sMouseX, "%ld", *mouseX );
        sprintf( sMouseY, "%ld", *mouseY );
        sprintf( bufferLength, "%d", *encodedLength );

        LOG_DEBUG("E.F.D. Length we're sending...");
        LOG_DEBUG(bufferLength);

        return make_final_JSON(ENCODE_FRAME_DIFFERENCE, clean_data, sMouseX, sMouseY, bufferLength);
}