Subversion Repositories SmartDukaan

/*
 * Copyright (c) 2013 BlackBerry Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <string>
#include <sstream>
#include <json/reader.h>
#include <json/writer.h>
#include <pthread.h>
#include "keyboard_ndk.hpp"
#include "keyboard_js.hpp"
#include <QtCore>
namespace webworks {

Keyboard_NDK::Keyboard_NDK(Keyboard_JS *parent):
        m_pParent(parent),
        keyboardProperty(50),
        keyboardThreadCount(1),
        threadHalt(true),
        m_thread(0) {
                pthread_cond_t cond  = PTHREAD_COND_INITIALIZER;
                pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
           bps_initialize();

            virtualkeyboard_request_events(0);

            virtualkeyboard_change_options(VIRTUALKEYBOARD_LAYOUT_EMAIL,VIRTUALKEYBOARD_ENTER_DEFAULT);

                m_pParent->getLog()->info("Keyboard Created");


}


Keyboard_NDK::~Keyboard_NDK() {
    //bps_shutdown();
}


// Loops and runs the callback method
void* KeyboardThread(void* parent) {
        Keyboard_NDK *pParent = static_cast<Keyboard_NDK *>(parent);

        sleep(1);

         // 1. Start the library
         bps_initialize();

         // 2. Request events to flow into the event queue
         virtualkeyboard_request_events(0);

         sleep(3);
         // 3. Use any service at any time
         //virtualkeyboard_show(); // Show the virtual keyboard

         // 4. Listen for events
         for (;;) {
           // get an event
            bps_event_t *event;
            bps_get_event(&event, -1); // blocking

            // handle the event
            pParent->event(event);
         }
         return NULL;
}

// Starts the thread and returns a message on status
std::string Keyboard_NDK::keyboardStartThread() {
    m_pParent->NotifyEvent("Teste");
    if (!m_thread) {
            m_pParent->NotifyEvent("Teste");
                int rc;
            rc = pthread_mutex_lock(&mutex);
            threadHalt = false;
            rc = pthread_cond_signal(&cond);
            rc = pthread_mutex_unlock(&mutex);

                pthread_attr_t thread_attr;
                pthread_attr_init(&thread_attr);
                pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);

                pthread_create(&m_thread, &thread_attr, KeyboardThread,
                                static_cast<void *>(this));
                pthread_attr_destroy(&thread_attr);
                //threadCallbackId = callbackId;
                m_pParent->getLog()->info("Thread Started");
                return "Thread Started";
        } else {
                m_pParent->getLog()->warn("Thread Started but already running");
                return "Thread Running";
        }
}


void Keyboard_NDK::event(bps_event_t *event) {
    Json::FastWriter writer;
    Json::Value root;
    root["threadCount"] = "10";
    int domain = bps_event_get_domain(event);
      if (domain == virtualkeyboard_get_domain()) {
          int code = bps_event_get_code(event);
          int a;
          std::string str;
          std::string eventString;
          std::ostringstream strs;
          switch(code) {
              case VIRTUALKEYBOARD_EVENT_VISIBLE:
                  eventString = "native.keyboardshow";
                  eventString.append(" ");
                  virtualkeyboard_get_height(&a) ;
                  strs << a;
                  str = strs.str();
                  eventString.append("{\"keyboardHeight\":\""+str+"\"}");
                  m_pParent->NotifyEvent(eventString);

                  break;
              case VIRTUALKEYBOARD_EVENT_HIDDEN:

                  m_pParent->NotifyEvent("native.keyboardhide");
                  break;
          }
      }

}
void Keyboard_NDK::callKeyboardEmail(){
    virtualkeyboard_change_options(VIRTUALKEYBOARD_LAYOUT_EMAIL,VIRTUALKEYBOARD_ENTER_SEND);
    virtualkeyboard_show();
}

void Keyboard_NDK::callKeyboardNumber(){

    virtualkeyboard_change_options(VIRTUALKEYBOARD_LAYOUT_NUMBER,VIRTUALKEYBOARD_ENTER_SEND);
    virtualkeyboard_show();
}
void Keyboard_NDK::cancelKeyboard(){
    virtualkeyboard_hide();
}




}