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/singleton.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 #include <Logger.h>
  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                 LoggerD("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                         LoggerE("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                 LoggerD("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                         LoggerE("Callback private data is NULL.");
  62                 }
  63
  64         }
  65         static void NFCInitializeCompletedCallback(nfc_error_e result, void *user_data) {
  66                 LoggerD("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                 LoggerD("Callback NFCSetActivationCompletedCallback.");
  72                 NFCDefaultAdapterSingleton::Instance().setPoweredManualAnswer(error);
  73         }
  74
  75 }//private namespace
  76
  77 NFCDefaultAdapter::NFCDefaultAdapter()
  78         :m_initialized(false) {
  79         LoggerD("NFC Enter");
  80
  81         m_NFCTagListeners.clear();
  82         m_NFCTargetListeners.clear();
  83         m_poweredAdapter = NULL;
  84 }
  85
  86 NFCDefaultAdapter::~NFCDefaultAdapter() {
  87         LoggerD("Enter");
  88         deinitialze();
  89 }
  90
  91 void NFCDefaultAdapter::setExclusiveMode(bool mode) {
  92         LoggerD("Enter");
  93         LoggerD("initilized:" << m_initialized);
  94         if (!m_initialized) {
  95
  96                 if (nfc_manager_initialize_sync() != NFC_ERROR_NONE) {
  97                         ThrowMsg(UnknownException, "Could not initialize NFC.");
  98                 }
  99                 m_initialized = true;
 100 /*
 101                 if (initialize() != NFC_ERROR_NONE) {
 102                         m_NFCTagListeners.clear();
 103                         ThrowMsg(PlatformException, "Could not initialize NFC.");
 104                 }
 105                 m_initialized = true;
 106 */
 107         }
 108         bool bEnabled = !mode;
 109         LoggerD("system handeler enable?" << bEnabled);
 110         // If exclusive mode is true, system handler has to be disabled.
 111         if (nfc_manager_set_system_handler_enable(bEnabled) != NFC_ERROR_NONE)
 112                 ThrowMsg(UnknownException, "Failed to set exclusive mode.");
 113         LoggerD("End");
 114 }
 115
 116 bool NFCDefaultAdapter::isSupported() {
 117         return nfc_manager_is_supported();
 118 }
 119
 120 void NFCDefaultAdapter::deinitialze() {
 121         LoggerD("Enter");
 122         int result = -1;
 123
 124         m_NFCTagListeners.clear();
 125         m_NFCTargetListeners.clear();
 126         m_poweredAdapter = NULL;
 127
 128         nfc_manager_unset_tag_discovered_cb();
 129         nfc_manager_unset_p2p_target_discovered_cb();
 130
 131         unsetExclusiveMode();
 132
 133         if(m_initialized == true)
 134         {
 135                 result = nfc_manager_deinitialize ();
 136                 if (result !=NFC_ERROR_NONE) {
 137                         LoggerI("failed to deinitialize nfc");
 138                 }
 139         }
 140         m_initialized = false;
 141
 142         LoggerD("destroy nfc");
 143 }
 144
 145 void NFCDefaultAdapter::unsetExclusiveMode() {
 146         LoggerD("entered");
 147         if (m_initialized)
 148                 if (nfc_manager_set_system_handler_enable(true) != NFC_ERROR_NONE)
 149                         LoggerD("failed to unset exclusive mode");
 150 }
 151
 152 int NFCDefaultAdapter::setTagListener(NFCAdapter * adapter) {
 153         LoggerD(" NFCDefaultAdapter::setTagListener Entered");
 154         int result = -1;
 155
 156         m_NFCTagListeners.push_back(adapter);
 157
 158         if (!m_initialized) {
 159                 if (initialize() != NFC_ERROR_NONE) {
 160                         m_NFCTagListeners.clear();
 161                         ThrowMsg(PlatformException, "Could not initialize NFC.");
 162                 }
 163                 nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
 164         } else {
 165                 nfc_tag_h currentTag;
 166                 if (nfc_manager_get_connected_tag(&currentTag) == NFC_ERROR_NONE)
 167                         adapter->NFCTagHasDetected((void *)currentTag);
 168         }
 169
 170         if (m_NFCTagListeners.size() > 1)
 171                 return 0;
 172
 173         result = nfc_manager_set_tag_discovered_cb (TagDetectedCallback, this);
 174
 175         NFCUtil util;
 176         if (result != NFC_ERROR_NONE) {
 177                 m_NFCTagListeners.pop_back();
 178                 util.throwNFCException(result, "failed to set callback of nfc_manager_set_tag_discovered_cb");
 179         }
 180
 181         LoggerI("NFCDefaultAdapter::setTagListener : result << " << result);
 182         return result;
 183 }
 184
 185 int NFCDefaultAdapter::setPeerListener(NFCAdapter *adapter) {
 186         LoggerD(" NFCDefaultAdapter::setPeerListener Entered");
 187         int result = -1;
 188
 189         m_NFCTargetListeners.push_back(adapter);
 190
 191         if (!m_initialized) {
 192                 if (initialize() != NFC_ERROR_NONE) {
 193                         m_NFCTargetListeners.clear();
 194                         ThrowMsg(PlatformException, "Could not initialize NFC.");
 195                 }
 196         } else {
 197                 nfc_p2p_target_h currentTarget;
 198                 if (nfc_manager_get_connected_target(&currentTarget) == NFC_ERROR_NONE)
 199                         adapter->NFCTargetHasDetected((void *)currentTarget);
 200         }
 201
 202         if (m_NFCTargetListeners.size() > 1)
 203                 return 0;
 204
 205         result = nfc_manager_set_p2p_target_discovered_cb (TargetDetectedCallback, this);
 206
 207         NFCUtil Util;
 208         if (result != NFC_ERROR_NONE) {
 209                 m_NFCTargetListeners.pop_back();
 210                 Util.throwNFCException(result, "failed to set callback of nfc_manager_set_p2p_target_discovered_cb");
 211         }
 212
 213         LoggerI("NFCDefaultAdapter::setPeerListener : result << " << result);
 214         return result;
 215 }
 216
 217 void NFCDefaultAdapter::unsetTagListener(NFCAdapter * adapter) {
 218         LoggerD(" NFCDefaultAdapter::unsetTagListener Entered");
 219
 220         if (!m_initialized) {
 221                 m_NFCTagListeners.clear();
 222                 return;
 223         }
 224
 225         std::vector<NFCAdapter *>::iterator it;
 226         for (it = m_NFCTagListeners.begin(); it != m_NFCTagListeners.end(); ++it) {
 227                 if (*it == adapter) {
 228                         m_NFCTagListeners.erase(it);
 229                         LoggerD("emitter is removed. (" << m_NFCTagListeners.size() << ")");
 230                         break;
 231                 }
 232         }
 233
 234         if (m_NFCTagListeners.empty())
 235                 nfc_manager_unset_tag_discovered_cb ();
 236 }
 237
 238 void NFCDefaultAdapter::unsetPeerListener(NFCAdapter * adapter) {
 239         LoggerD(" NFCDefaultAdapter::unsetPeerListener Entered");
 240
 241         if (!m_initialized) {
 242                 m_NFCTargetListeners.clear();
 243                 return;
 244         }
 245
 246         std::vector<NFCAdapter *>::iterator it;
 247         for (it = m_NFCTargetListeners.begin(); it != m_NFCTargetListeners.end(); ++it) {
 248                 if (*it == adapter) {
 249                         m_NFCTargetListeners.erase(it);
 250                         LoggerD("emitter is removed. (" << m_NFCTargetListeners.size() << ")");
 251                         break;
 252                 }
 253         }
 254
 255         if (m_NFCTargetListeners.empty())
 256                 nfc_manager_unset_p2p_target_discovered_cb();
 257
 258 }
 259
 260 void NFCDefaultAdapter::NFCTagHasDetected(void *props)
 261 {
 262         LoggerD("NFCDefaultAdapter::NFCTagHasDetected Enter type");
 263
 264         std::vector<NFCAdapter *>::iterator it;
 265         for (it = m_NFCTagListeners.begin(); it != m_NFCTagListeners.end(); ++it) {
 266                 (*it)->NFCTagHasDetected(props);
 267         }
 268 }
 269
 270 void NFCDefaultAdapter::NFCTargetHasDetected(void *props)
 271 {
 272         std::vector<NFCAdapter *>::iterator it;
 273         for (it = m_NFCTargetListeners.begin(); it != m_NFCTargetListeners.end(); ++it) {
 274                 (*it)->NFCTargetHasDetected(props);
 275         }
 276 }
 277
 278 void NFCDefaultAdapter::getCurrentNFC() {
 279         LoggerD("Enter");
 280
 281         if (!m_initialized) {
 282                 LoggerE("No Initialized");
 283                 return;
 284         }
 285
 286         if (!m_NFCTagListeners.empty()) {
 287                 nfc_tag_h currentTag;
 288                 if (nfc_manager_get_connected_tag(&currentTag) == NFC_ERROR_NONE) {
 289                         NFCTagHasDetected((void *)currentTag);
 290                         return;
 291                 }
 292         }
 293
 294         if (!m_NFCTargetListeners.empty()) {
 295                 nfc_p2p_target_h currentTarget;
 296                 if (nfc_manager_get_connected_target(&currentTarget) == NFC_ERROR_NONE) {
 297                         NFCTargetHasDetected((void *)currentTarget);
 298                 }
 299         }
 300 }
 301
 302 int NFCDefaultAdapter::initialize() {
 303         LoggerD("NFCDefaultAdapter::initialize Entered");
 304         int result = -1;
 305         //nfc_manager_deinitialize();
 306         result = nfc_manager_initialize(NFCInitializeCompletedCallback, this);
 307         if (result != NFC_ERROR_NONE) {
 308                 LoggerE("Could not initialize NFC.");
 309                 m_initialized = false;
 310         } else {
 311                 m_initialized = true;
 312         }
 313         return result;
 314 }
 315
 316 void *NFCDefaultAdapter::getCachedMessage() {
 317         LoggerD("Entered");
 318         nfc_ndef_message_h messageHandle = NULL;
 319         int result = nfc_manager_get_cached_message(&messageHandle);
 320         if ((result == NFC_ERROR_INVALID_NDEF_MESSAGE) || (result == NFC_ERROR_NO_NDEF_MESSAGE)) {
 321                 if (messageHandle)
 322                         nfc_ndef_message_destroy(messageHandle);
 323
 324                 return NULL;
 325         }
 326
 327         NFCUtil util;
 328         if (result != NFC_ERROR_NONE) {
 329                 util.throwNFCException(result, "Can't get cached message");
 330         }
 331         return (void *)(messageHandle);
 332 }
 333
 334 bool NFCDefaultAdapter::getPowerState() {
 335         return nfc_manager_is_activated();
 336 }
 337
 338 void NFCDefaultAdapter::setPowered(const bool state, NFCAdapter * poweredAdapter) {
 339         LoggerD("Enter");
 340         try {
 341                 if (m_poweredAdapter != NULL) {
 342                         ThrowMsg(PlatformException, "Progressing Identical Operation");
 343                         return;
 344                 } else if (getPowerState() == state) {
 345                         poweredAdapter->setPoweredManualAnswer(NFC_ERROR_NONE);
 346                         return;
 347                 }
 348
 349                 int result = NFC_ERROR_NONE;
 350                 if (!m_initialized)
 351                         result = initialize();
 352
 353                 if (result == NFC_ERROR_NONE) {
 354                         m_poweredAdapter = poweredAdapter;
 355                         result = nfc_manager_set_activation(state, NFCSetActivationCompletedCallback, NULL);
 356                 }
 357
 358                 if (result != NFC_ERROR_NONE) {
 359                         poweredAdapter->setPoweredManualAnswer(result);
 360                         m_poweredAdapter = NULL;
 361                 }
 362         } catch (const WrtDeviceApis::Commons::Exception& ex) {
 363                 LoggerE("Exception: " << ex.GetMessage());
 364                 poweredAdapter->setPoweredManualAnswer(NFC_ERROR_OPERATION_FAILED);
 365                 m_poweredAdapter = NULL;
 366         }
 367 }
 368
 369 void NFCDefaultAdapter::setPoweredManualAnswer(int error) {
 370         if (m_poweredAdapter != NULL) {
 371                 m_poweredAdapter->setPoweredManualAnswer(error);
 372                 m_poweredAdapter = NULL;
 373         }
 374 }
 375
 376
 377 }
 378 }