src/NFC/NFCDefaultAdapter.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 <dpl/log/log.h>
  19 #include <dpl/scoped_ptr.h>
  20 #include <dpl/singleton_impl.h>
  21 #include <Commons/Exception.h>
  22 #include <JSTizenException.h>
  23 #include <nfc.h>
  24 #include "NFCDefaultAdapter.h"
  25 #include "NFCUtil.h"
  26
  27
  28 using namespace DPL;
  29 IMPLEMENT_SINGLETON(DeviceAPI::NFC::NFCDefaultAdapter)
  30
  31 namespace DeviceAPI {
  32 namespace NFC {
  33
  34 namespace
  35 {
  36         static void TagDetectedCallback(nfc_discovered_type_e type, nfc_tag_h tag, void *data) {
  37                 LogDebug("Callback TagDetectedCallback.");
  38
  39                 if (data) {
  40                         if (NFC_DISCOVERED_TYPE_ATTACHED == type) {
  41                                 (static_cast<NFCDefaultAdapter*>(data))->NFCTagHasDetected((void *)tag);
  42                         } else {
  43                                 (static_cast<NFCDefaultAdapter*>(data))->NFCTagHasDetected(NULL);
  44                         }
  45                 } else {
  46                         LogError("Callback private data is NULL.");
  47                 }
  48
  49         }
  50
  51         static void TargetDetectedCallback(nfc_discovered_type_e type, nfc_p2p_target_h target, void *data) {
  52                 LogDebug("Callback TargetDetectedCallback.");
  53
  54                 if (data) {
  55                         if (NFC_DISCOVERED_TYPE_ATTACHED == type) {
  56                                 (static_cast<NFCDefaultAdapter*>(data))->NFCTargetHasDetected((void *)target);
  57                         } else {
  58                                 (static_cast<NFCDefaultAdapter*>(data))->NFCTargetHasDetected(NULL);
  59                         }
  60                 } else {
  61                         LogError("Callback private data is NULL.");
  62                 }
  63
  64         }
  65         static void NFCInitializeCompletedCallback(nfc_error_e result, void *user_data) {
  66                 LogDebug("Callback NFCInitializeCompletedCallback. result : " << (int)result);
  67                 if (user_data && (result == NFC_ERROR_NONE))
  68                         (static_cast<NFCDefaultAdapter*>(user_data))->getCurrentNFC();
  69         }
  70         static void NFCSetActivationCompletedCallback(nfc_error_e error, void *user_data) {
  71                 LogDebug("Callback NFCSetActivationCompletedCallback.");
  72                 NFCDefaultAdapterSingleton::Instance().setPoweredManualAnswer(error);
  73         }
  74
  75 }//private namespace
  76
  77 NFCDefaultAdapter::NFCDefaultAdapter()
  78         :m_initialized(false) {
  79         LogDebug("NFC Enter");
  80
  81         m_NFCTagListeners.clear();
  82         m_NFCTargetListeners.clear();
  83         m_poweredAdapter = NULL;
  84 }
  85
  86 NFCDefaultAdapter::~NFCDefaultAdapter() {
  87         LogDebug("Enter");
  88         deinitialze();
  89 }
  90
  91 bool NFCDefaultAdapter::isSupported() {
  92         return nfc_manager_is_supported();
  93 }
  94
  95 void NFCDefaultAdapter::deinitialze() {
  96         LogDebug("Enter");
  97         int result = -1;
  98
  99         m_NFCTagListeners.clear();
 100         m_NFCTargetListeners.clear();
 101         m_poweredAdapter = NULL;
 102
 103         nfc_manager_unset_tag_discovered_cb();
 104         nfc_manager_unset_p2p_target_discovered_cb();
 105
 106         if(m_initialized == true)
 107         {
 108                 result = nfc_manager_deinitialize ();
 109                 if (result !=NFC_ERROR_NONE) {
 110                         LogInfo("failed to deinitialize nfc");
 111                 }
 112         }
 113         m_initialized = false;
 114
 115         LogDebug("destroy nfc");
 116 }
 117
 118 int NFCDefaultAdapter::setTagListener(NFCAdapter * adapter) {
 119         LogDebug(" NFCDefaultAdapter::setTagListener Entered");
 120         int result = -1;
 121
 122         m_NFCTagListeners.push_back(adapter);
 123
 124         if (!m_initialized) {
 125                 if (initialize() != NFC_ERROR_NONE) {
 126                         m_NFCTagListeners.clear();
 127                         ThrowMsg(PlatformException, "Could not initialize NFC.");
 128                 }
 129         } else {
 130                 nfc_tag_h currentTag;
 131                 if (nfc_manager_get_connected_tag(&currentTag) == NFC_ERROR_NONE)
 132                         adapter->NFCTagHasDetected((void *)currentTag);
 133         }
 134
 135         if (m_NFCTagListeners.size() > 1)
 136                 return 0;
 137
 138         result = nfc_manager_set_tag_discovered_cb (TagDetectedCallback, this);
 139
 140         NFCUtil util;
 141         if (result != NFC_ERROR_NONE) {
 142                 m_NFCTagListeners.pop_back();
 143                 util.throwNFCException(result, "failed to set callback of nfc_manager_set_tag_discovered_cb");
 144         }
 145
 146         LogInfo("NFCDefaultAdapter::setTagListener : result << " << result);
 147         return result;
 148 }
 149
 150 int NFCDefaultAdapter::setPeerListener(NFCAdapter *adapter) {
 151         LogDebug(" NFCDefaultAdapter::setPeerListener Entered");
 152         int result = -1;
 153
 154         m_NFCTargetListeners.push_back(adapter);
 155
 156         if (!m_initialized) {
 157                 if (initialize() != NFC_ERROR_NONE) {
 158                         m_NFCTargetListeners.clear();
 159                         ThrowMsg(PlatformException, "Could not initialize NFC.");
 160                 }
 161         } else {
 162                 nfc_p2p_target_h currentTarget;
 163                 if (nfc_manager_get_connected_target(&currentTarget) == NFC_ERROR_NONE)
 164                         adapter->NFCTargetHasDetected((void *)currentTarget);
 165         }
 166
 167         if (m_NFCTargetListeners.size() > 1)
 168                 return 0;
 169
 170         result = nfc_manager_set_p2p_target_discovered_cb (TargetDetectedCallback, this);
 171
 172         NFCUtil Util;
 173         if (result != NFC_ERROR_NONE) {
 174                 m_NFCTargetListeners.pop_back();
 175                 Util.throwNFCException(result, "failed to set callback of nfc_manager_set_p2p_target_discovered_cb");
 176         }
 177
 178         LogInfo("NFCDefaultAdapter::setPeerListener : result << " << result);
 179         return result;
 180 }
 181
 182 void NFCDefaultAdapter::unsetTagListener(NFCAdapter * adapter) {
 183         LogDebug(" NFCDefaultAdapter::unsetTagListener Entered");
 184
 185         if (!m_initialized) {
 186                 if (initialize() != NFC_ERROR_NONE) {
 187                         ThrowMsg(PlatformException, "Could not initialize NFC.");
 188                 }
 189         }
 190
 191         std::vector<NFCAdapter *>::iterator it;
 192         for (it = m_NFCTagListeners.begin(); it != m_NFCTagListeners.end(); ++it) {
 193                 if (*it == adapter) {
 194                         m_NFCTagListeners.erase(it);
 195                         LogDebug("emitter is removed. (" << m_NFCTagListeners.size() << ")");
 196                         break;
 197                 }
 198         }
 199
 200         if (m_NFCTagListeners.empty())
 201                 nfc_manager_unset_tag_discovered_cb ();
 202 }
 203
 204 void NFCDefaultAdapter::unsetPeerListener(NFCAdapter * adapter) {
 205         LogDebug(" NFCDefaultAdapter::unsetPeerListener Entered");
 206
 207         if (!m_initialized) {
 208                 if (initialize() != NFC_ERROR_NONE) {
 209                         ThrowMsg(PlatformException, "Could not initialize NFC.");
 210                 }
 211         }
 212
 213         std::vector<NFCAdapter *>::iterator it;
 214         for (it = m_NFCTargetListeners.begin(); it != m_NFCTargetListeners.end(); ++it) {
 215                 if (*it == adapter) {
 216                         m_NFCTargetListeners.erase(it);
 217                         LogDebug("emitter is removed. (" << m_NFCTargetListeners.size() << ")");
 218                         break;
 219                 }
 220         }
 221
 222         if (m_NFCTargetListeners.empty())
 223                 nfc_manager_unset_p2p_target_discovered_cb();
 224
 225 }
 226
 227 void NFCDefaultAdapter::NFCTagHasDetected(void *props)
 228 {
 229         LogDebug("NFCDefaultAdapter::NFCTagHasDetected Enter type");
 230
 231         std::vector<NFCAdapter *>::iterator it;
 232         for (it = m_NFCTagListeners.begin(); it != m_NFCTagListeners.end(); ++it) {
 233                 (*it)->NFCTagHasDetected(props);
 234         }
 235 }
 236
 237 void NFCDefaultAdapter::NFCTargetHasDetected(void *props)
 238 {
 239         std::vector<NFCAdapter *>::iterator it;
 240         for (it = m_NFCTargetListeners.begin(); it != m_NFCTargetListeners.end(); ++it) {
 241                 (*it)->NFCTargetHasDetected(props);
 242         }
 243 }
 244
 245 void NFCDefaultAdapter::getCurrentNFC() {
 246         LogDebug("Enter");
 247
 248         if (!m_initialized) {
 249                 LogError("No Initialized");
 250                 return;
 251         }
 252
 253         if (!m_NFCTagListeners.empty()) {
 254                 nfc_tag_h currentTag;
 255                 if (nfc_manager_get_connected_tag(&currentTag) == NFC_ERROR_NONE) {
 256                         NFCTagHasDetected((void *)currentTag);
 257                         return;
 258                 }
 259         }
 260
 261         if (!m_NFCTargetListeners.empty()) {
 262                 nfc_p2p_target_h currentTarget;
 263                 if (nfc_manager_get_connected_target(&currentTarget) == NFC_ERROR_NONE) {
 264                         NFCTargetHasDetected((void *)currentTarget);
 265                 }
 266         }
 267 }
 268
 269 int NFCDefaultAdapter::initialize() {
 270         LogDebug("NFCDefaultAdapter::initialize Entered");
 271         int result = -1;
 272         //nfc_manager_deinitialize();
 273         result = nfc_manager_initialize(NFCInitializeCompletedCallback, this);
 274         if (result != NFC_ERROR_NONE) {
 275                 LogError("Could not initialize NFC.");
 276                 m_initialized = false;
 277         } else {
 278                 m_initialized = true;
 279                 nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
 280         }
 281         return result;
 282 }
 283
 284 void *NFCDefaultAdapter::getCachedMessage() {
 285         LogDebug("Entered");
 286         nfc_ndef_message_h messageHandle = NULL;
 287         int result = nfc_manager_get_cached_message(&messageHandle);
 288         if ((result == NFC_ERROR_INVALID_NDEF_MESSAGE) || (result == NFC_ERROR_NO_NDEF_MESSAGE)) {
 289                 if (messageHandle)
 290                         nfc_ndef_message_destroy(messageHandle);
 291
 292                 return NULL;
 293         }
 294
 295         NFCUtil util;
 296         if (result != NFC_ERROR_NONE) {
 297                 if (messageHandle)
 298                         nfc_ndef_message_destroy(messageHandle);
 299
 300                 util.throwNFCException(result, "Can't get cached message");
 301         }
 302         return (void *)(messageHandle);
 303 }
 304
 305 bool NFCDefaultAdapter::getPowerState() {
 306         return nfc_manager_is_activated();
 307 }
 308
 309 void NFCDefaultAdapter::setPowered(const bool state, NFCAdapter * poweredAdapter) {
 310         LogDebug("Enter");
 311         try {
 312                 if (m_poweredAdapter != NULL) {
 313                         ThrowMsg(PlatformException, "Progressing Identical Operation");
 314                         return;
 315                 } else if (getPowerState() == state) {
 316                         poweredAdapter->setPoweredManualAnswer(NFC_ERROR_NONE);
 317                         return;
 318                 }
 319
 320                 int result = NFC_ERROR_NONE;
 321                 if (!m_initialized)
 322                         result = initialize();
 323
 324                 if (result == NFC_ERROR_NONE) {
 325                         m_poweredAdapter = poweredAdapter;
 326                         result = nfc_manager_set_activation(state, NFCSetActivationCompletedCallback, NULL);
 327                 }
 328
 329                 if (result != NFC_ERROR_NONE) {
 330                         poweredAdapter->setPoweredManualAnswer(result);
 331                         m_poweredAdapter = NULL;
 332                 }
 333         } catch (const WrtDeviceApis::Commons::Exception& ex) {
 334                 LogError("Exception: " << ex.GetMessage());
 335                 poweredAdapter->setPoweredManualAnswer(NFC_ERROR_OPERATION_FAILED);
 336                 m_poweredAdapter = NULL;
 337         }
 338 }
 339
 340 void NFCDefaultAdapter::setPoweredManualAnswer(int error) {
 341         if (m_poweredAdapter != NULL) {
 342                 m_poweredAdapter->setPoweredManualAnswer(error);
 343                 m_poweredAdapter = NULL;
 344         }
 345 }
 346
 347
 348 }
 349 }