src/NFC/NFCTarget.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <Commons/Exception.h>
  19 #include "NFCTarget.h"
  20 #include "NFCUtil.h"
  21 #include <Logger.h>
  22
  23 namespace DeviceAPI {
  24 namespace NFC {
  25
  26 using namespace WrtDeviceApis;
  27
  28 namespace
  29 {
  30         /**
  31         * Callback method called by platform as interval time.
  32         * @param event_type Platform magnetic evet type
  33         * @param event Platform sensor event data
  34         * @param this_ User data pointer.
  35         */
  36         static void TargetReceivedCallback(nfc_p2p_target_h target, nfc_ndef_message_h message, void *user_data) {
  37                 LoggerD("Callback TargetReceivedCallback.");
  38                 if (user_data) {
  39                         unsigned char *rawdata = NULL;
  40                         unsigned int size;
  41                         if (nfc_ndef_message_get_rawdata(message, &rawdata, &size) != NFC_ERROR_NONE) {
  42                                 LoggerE("Can't get rawdata of message");
  43                                 if (rawdata)
  44                                         free(rawdata);
  45                                 return;
  46                         }
  47
  48                         NFCUtil util;
  49                         std::vector<unsigned char> receiveData = util.toVector(rawdata, size);
  50                         if (rawdata)
  51                                 free(rawdata);
  52                         ((NFCTarget *)user_data)->receiveNdef(receiveData);
  53                 } else {
  54                         LoggerD("Error! TargetReceivedCallback is Null.");
  55                 }
  56         }
  57
  58         static void TargetSentCallback(nfc_error_e result, void *user_data) {
  59                 LoggerD("Callback TargetSentCallback.");
  60                 if (user_data) {
  61                         ((NFCTarget *)user_data)->sendNDEFManualAnswer((unsigned int)result);
  62
  63                 } else {
  64                         LoggerD("Error! TargetSentCallback is Null.");
  65                 }
  66         }
  67 }//private namespace
  68
  69 NFCTarget::NFCTarget(void *targetHandle)
  70 {
  71         LoggerD("entered");
  72
  73         if (targetHandle == NULL)
  74                 ThrowMsg(Commons::UnknownException, "Target Handler is Null Pointer.");
  75
  76         handle = (nfc_p2p_target_h)targetHandle;
  77         LoggerD("handle:"<<targetHandle);
  78         m_isSetReceiveListenter = false;
  79         m_EventTargetActionSendPtr.Reset();
  80 }
  81
  82 NFCTarget::~NFCTarget()
  83 {
  84         LoggerD("entered");
  85         handle = NULL;
  86 }
  87
  88 bool NFCTarget::isConnected() {
  89         nfc_p2p_target_h curHandle = NULL;
  90         if (nfc_manager_get_connected_target(&curHandle) == NFC_ERROR_NONE) {
  91                 if (curHandle == handle)
  92                         return true;
  93         }
  94         return false;
  95 }
  96
  97 void NFCTarget::setReceiveNDEFListener(const EventTargetActionReceiveEmitterPtr& event) {
  98         LoggerD("Enter");
  99         if (m_isSetReceiveListenter == true)
 100                 ThrowMsg(Commons::AlreadyInUseException, "Already set Listener");
 101
 102         m_emitter = event;
 103         m_isSetReceiveListenter = true;
 104
 105         int result = nfc_p2p_set_data_received_cb(handle, TargetReceivedCallback, this);
 106
 107         NFCUtil util;
 108         if (result != NFC_ERROR_NONE) {
 109                 m_isSetReceiveListenter = false;
 110                 util.throwNFCException(result, "Can't set Receive Ndef Listener");
 111         }
 112 }
 113
 114 void NFCTarget::receiveNdef(std::vector<unsigned char>&messageData) {
 115         LoggerD("Enter");
 116         if ((m_isSetReceiveListenter == true) && (m_emitter.Get() != NULL)) {
 117                 EventTargetActionReceivePtr event(new EventTargetActionReceive());
 118                 event->setReadNdefResult(messageData);
 119                 m_emitter->emit(event);
 120         }
 121 }
 122
 123 void NFCTarget::unsetReceiveNDEFListener() {
 124         LoggerD("Enter");
 125         if (m_isSetReceiveListenter == true) {
 126                 nfc_p2p_unset_data_received_cb(handle);
 127                 LoggerD("Success to unset Listener");
 128         } else {
 129                 LoggerD("No set Listener");
 130         }
 131         m_isSetReceiveListenter = false;
 132 }
 133
 134 void NFCTarget::sendNDEF(const EventTargetActionSendPtr& event) {
 135         LoggerD("Enter");
 136
 137         if (m_EventTargetActionSendPtr.Get() != NULL)
 138                 m_EventTargetActionSends.push_back(event);
 139         else
 140                 EventRequestReceiver<EventTargetActionSend>::PostRequest(event);
 141
 142         return;
 143 }
 144
 145 void NFCTarget::sendNDEFManualAnswer(unsigned int result) {
 146         LoggerD("Enter");
 147         if (m_EventTargetActionSendPtr.Get() != NULL) {
 148                 if ((nfc_error_e)result == NFC_ERROR_NONE) {
 149                         m_EventTargetActionSendPtr->setResult(TRUE);
 150                 } else {
 151                         NFCUtil util;
 152                         m_EventTargetActionSendPtr->setResult(FALSE);
 153                         m_EventTargetActionSendPtr->setError(util.getNFCErrorString(result));
 154                         m_EventTargetActionSendPtr->setErrorMessage(util.getNFCErrorMessage(result));
 155                 }
 156                 EventRequestReceiver<EventTargetActionSend>::ManualAnswer(m_EventTargetActionSendPtr);
 157
 158                 m_EventTargetActionSendPtr.Reset();
 159
 160                 if (m_EventTargetActionSends.size() > 0) {
 161                         EventTargetActionSendPtr event = m_EventTargetActionSends.front();
 162                         m_EventTargetActionSends.erase(m_EventTargetActionSends.begin());
 163                         LoggerD("m_EventTargetActionSends is removed. (" << m_EventTargetActionSends.size() << ")");
 164                         EventRequestReceiver<EventTargetActionSend>::PostRequest(event);
 165                 }
 166         }
 167 }
 168
 169 void NFCTarget::OnRequestReceived(const EventTargetActionSendPtr& event) {
 170         LoggerD("Enter");
 171         try {
 172                 event->switchToManualAnswer();
 173                 m_EventTargetActionSendPtr = event;
 174
 175                 nfc_ndef_message_h message = (nfc_ndef_message_h)event->getMessageForSending();
 176                 int result = nfc_p2p_send(handle, message, TargetSentCallback, this);
 177
 178                 NFCUtil util;
 179                 std::string error = util.getNFCErrorString(result);
 180                 if (error != "") {
 181                         sendNDEFManualAnswer(result);
 182                 }
 183         } catch (const Commons::Exception& ex) {
 184                 LoggerE("Exception: " << ex.GetMessage());
 185                 if (event != m_EventTargetActionSendPtr)
 186                         m_EventTargetActionSendPtr = event;
 187                 sendNDEFManualAnswer(NFC_ERROR_OPERATION_FAILED);
 188         }
 189 }
 190
 191 }
 192 }