Beta merge 2
[profile/ivi/wrt-plugins-tizen.git] / src / platform / Tizen / NFC / NFCManager.cpp
1 /*
2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
3  *
4  * Licensed under the Apache License, Version 2.0 (the License);
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an AS IS BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17
18 #include <dpl/log/log.h>
19 #include <dpl/scoped_ptr.h>
20 #include <Commons/Exception.h>
21 #include <nfc.h>
22 #include "NFCManager.h"
23 #include "NFCUtil.h"
24
25 using namespace TizenApis::Api::NFC;
26 using namespace DPL;
27
28 namespace TizenApis {
29 namespace Platform {
30 namespace NFC {
31
32 namespace
33 {
34         static void TagDetectedCallback(nfc_discovered_type_e type, nfc_tag_h tag, void *data) {
35                 LogDebug("Callback TagDetectedCallback.");
36
37                 if (data) {
38                         if (NFC_DISCOVERED_TYPE_ATTACHED == type) {
39                                 (static_cast<NFCManager*>(data))->updateCurrentHandle((void *)tag);
40                                 (static_cast<NFCManager*>(data))->NFCHasDetected((void *)tag, NFC_TAG_TYPE);
41                         } else {
42                                 (static_cast<NFCManager*>(data))->updateCurrentHandle(NULL);
43                                 (static_cast<NFCManager*>(data))->NFCHasDetected(NULL, NFC_TAG_TYPE);
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<NFCManager*>(data))->updateCurrentHandle((void *)target);
57                                 (static_cast<NFCManager*>(data))->NFCHasDetected((void *)target, NFC_TARGET_TYPE);
58                         } else {
59                                 (static_cast<NFCManager*>(data))->updateCurrentHandle(NULL);
60                                 (static_cast<NFCManager*>(data))->NFCHasDetected(NULL, NFC_TARGET_TYPE);
61                         }
62                 } else {
63                         LogError("Callback private data is NULL.");
64                 }
65
66         }
67
68         static void NDEFDetectedCallback(nfc_ndef_message_h message, void *data) {
69                 LogDebug("Callback NDEFDetectedCallback.");
70                 if (data) {
71                         unsigned char *UrawData;
72                         int size;
73
74                         if (nfc_ndef_message_get_rawdata(message, &UrawData, &size) != NFC_ERROR_NONE) {
75                                 LogError("Can't get rawdata of message");
76                                 return;
77                         }
78
79                         NFCUtil Util;
80                         (static_cast<NFCManager*>(data))->NDEFHasDetected(Util.toVector(UrawData, size));
81
82                 } else {
83                         LogError("Callback private data is NULL.");
84                 }
85         }
86
87         static void SeEventCallback(nfc_se_event_e event, void *data) {
88                 LogDebug("Callback NDEFDetectedCallback.");
89                 if (data) {
90                         nfcSeEventType seEvent = NFC_SE_EVENTTYPE_END_TRANSACTION;
91                         switch(event) {
92                                 case NFC_SE_EVENT_START_TRANSACTION:
93                                         seEvent = NFC_SE_EVENTTYPE_START_TRANSACTION;
94                                         break;
95                                 case NFC_SE_EVENT_END_TRANSACTION:
96                                         seEvent = NFC_SE_EVENTTYPE_END_TRANSACTION;
97                                         break;
98                                 case NFC_SE_EVENT_CONNECTIVITY:
99                                         seEvent = NFC_SE_EVENTTYPE_CONNECTIVITY;
100                                         break;
101                                 case NFC_SE_EVENT_FIELD_ON:
102                                         seEvent = NFC_SE_EVENTTYPE_FIELD_ON;
103                                         break;
104                                 case NFC_SE_EVENT_FIELD_OFF:
105                                         seEvent = NFC_SE_EVENTTYPE_FIELD_OFF;
106                                         break;
107                         }
108                         (static_cast<NFCManager*>(data))->SeEventHasDetected(seEvent);
109
110                 } else {
111                         LogError("Callback private data is NULL.");
112                 }
113         }
114 }//private namespace
115
116 NFCManager::NFCManager()
117         :m_initialized(false) {
118         LogDebug("Platform::NFC Enter");
119         initialize();
120         curHandle = NULL;
121
122         m_managerPriv = NULL;
123
124         m_NFCTagEmitterPtr.Reset();
125         m_NFCTargetEmitterPtr.Reset();
126         m_NdefEmitterPtr.Reset();
127         m_SeEventEmitterPtr.Reset();
128
129         m_tagFilter.Reset();
130
131 }
132
133 NFCManager::~NFCManager() {
134         LogDebug("Enter");
135         int result = -1;
136         if(m_initialized == true)
137 {
138                 result = nfc_manager_deinitialize ();
139                 if (result !=NFC_ERROR_NONE) {
140                         LogInfo("failed to deinitialize nfc");
141                 }
142         }
143
144         nfc_manager_unset_tag_discovered_cb();
145         nfc_manager_unset_p2p_target_discovered_cb();
146         nfc_manager_unset_ndef_discovered_cb();
147         nfc_manager_unset_se_event_cb();
148
149         m_managerPriv = NULL;
150
151         LogDebug("destroy nfc");
152 }
153
154 int NFCManager::setTagListener(const EventNFCChangedEmitterPtr& emitter,
155                 TagFilterPtr pFilter, void *managerPriv) {
156         LogDebug(" NFCManager::setTagListener Entered");
157         int result = -1;
158
159         if (m_NFCTagEmitterPtr.Get() != NULL)
160                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
161
162         m_NFCTagEmitterPtr = emitter;
163         m_managerPriv = managerPriv;
164
165         LogDebug(" NFCManager::setTagListener set discovered callback, filter size == " << pFilter->getFilterSize());
166
167         m_tagFilter = pFilter;
168         if (pFilter->getFilterSize() > 0) {
169                 int filter = NFC_TAG_FILTER_ALL_DISABLE;
170                 for (int cnt = 0; cnt < pFilter->getFilterSize() ; cnt++) {
171                         LogDebug(" NFCManager::setTagListener filter == " << pFilter->getFilterValue(cnt));
172                         if ((pFilter->getFilterValue(cnt) >= NFC_TAGTYPE_ISO14443_A_PICC) && (pFilter->getFilterValue(cnt) <= NFC_TAGTYPE_MIFARE_DESFIRE_PICC))
173                                 filter = filter |NFC_TAG_FILTER_ISO14443A_ENABLE;
174                         else if ((pFilter->getFilterValue(cnt) >= NFC_TAGTYPE_ISO14443_B_PICC) && (pFilter->getFilterValue(cnt) <= NFC_TAGTYPE_ISO14443_BPRIME_PICC))
175                                 filter = filter |NFC_TAG_FILTER_ISO14443B_ENABLE;
176                         else if (pFilter->getFilterValue(cnt) == NFC_TAGTYPE_FELICA_PICC)
177                                 filter = filter |NFC_TAG_FILTER_FELICA_ENABLE ;
178                         else if (pFilter->getFilterValue(cnt) == NFC_TAGTYPE_JEWEL_PICC)
179                                 filter = filter |NFC_TAG_FILTER_JEWEL_ENABLE  ;
180                         else if (pFilter->getFilterValue(cnt) == NFC_TAGTYPE_ISO15693_PICC)
181                                 filter = filter |NFC_TAG_FILTER_ISO15693_ENABLE ;
182                 }
183                 nfc_manager_set_tag_filter(filter);
184         } else {
185                 nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
186         }
187
188         result = nfc_manager_set_tag_discovered_cb (TagDetectedCallback, this);
189         if (result != NFC_ERROR_NONE)
190         {
191                 LogInfo("failed to set callback of nfc_manager_set_ndef_discovered_cb");
192                 return result;
193         }
194         LogInfo("NFCManager::setTagListener : result << " << result);
195         return result;
196 }
197
198 int NFCManager::setPeerListener(const EventNFCChangedEmitterPtr& emitter, void *managerPriv) {
199         LogDebug(" NFCManager::setPeerListener Entered");
200         int result = -1;
201
202         if (m_NFCTargetEmitterPtr.Get() != NULL)
203                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
204
205         m_NFCTargetEmitterPtr = emitter;
206         m_managerPriv = managerPriv;
207         result = nfc_manager_set_p2p_target_discovered_cb (TargetDetectedCallback, this);
208
209         if (result != NFC_ERROR_NONE)
210         {
211                 LogInfo("failed to set callback of nfc_manager_set_p2p_target_discovered_cb");
212                 return result;
213         }
214
215         LogInfo("NFCManager::setPeerListener : result << " << result);
216         return result;
217 }
218
219 int NFCManager::setNDEFListener(const EventNFCChangedNdefEmitterPtr& emitter) {
220         LogDebug(" NFCManager::setNDEFListener Entered");
221         int result = -1;
222
223         if (m_NdefEmitterPtr.Get() != NULL)
224                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
225
226         m_NdefEmitterPtr = emitter;
227         result = nfc_manager_set_ndef_discovered_cb(NDEFDetectedCallback, this);
228         if (result != NFC_ERROR_NONE)
229         {
230                 LogInfo("failed to set callback of nfc_manager_set_ndef_discovered_cb");
231                 return result;
232         }
233         nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
234         LogInfo("NFCManager::setNDEFListener : result << " << result);
235         return result;
236 }
237
238 int NFCManager::setSEEventListener(const EventNFCChangedSeEventEmitterPtr& emitter) {
239         LogDebug(" NFCManager::setNDEFListener Entered");
240         int result = -1;
241
242         if (m_SeEventEmitterPtr.Get() != NULL)
243                 Throw(WrtDeviceApis::Commons::AlreadyInUseException);
244
245         m_SeEventEmitterPtr = emitter;
246         result = nfc_manager_set_se_event_cb (SeEventCallback, this);
247         if (result != NFC_ERROR_NONE)
248         {
249                 LogInfo("failed to set callback of NFC_manager_set_tag_discovered_cb");
250                 return result;
251         }
252         LogInfo("NFCManager::setSEEventListener : result << " << result);
253         return result;
254 }
255
256 void NFCManager::unsetTagListener(/*EventNFCChangedEmitter::IdType id*/) {
257         LogDebug(" NFCManager::unsetTagListener Entered");
258
259         nfc_manager_unset_tag_discovered_cb ();
260         m_NFCTagEmitterPtr.Reset();
261         }
262
263 void NFCManager::unsetPeerListener(/*EventNFCChangedEmitter::IdType id*/) {
264         LogDebug(" NFCManager::unsetPeerListener Entered");
265         nfc_manager_unset_p2p_target_discovered_cb();
266         m_NFCTargetEmitterPtr.Reset();
267 }
268
269
270 void NFCManager::unsetNDEFListener() {
271         LogDebug(" NFCManager::unsetNDEFListener Entered");
272         nfc_manager_unset_ndef_discovered_cb();
273         m_NdefEmitterPtr.Reset();
274 }
275
276 void NFCManager::unsetSEEventListener() {
277         LogDebug(" NFCManager::unsetSEEventListener Entered");
278         nfc_manager_unset_se_event_cb();
279         m_SeEventEmitterPtr.Reset();
280 }
281
282 void NFCManager::NFCHasDetected(void *props, EventNFCType type)
283 {
284         LogDebug("NFCManager::NFCHasDetected Enter type : " << type);
285
286         if (((m_NFCTagEmitterPtr.Get() != NULL) && (type == NFC_TAG_TYPE)) ||
287                 ((m_NFCTargetEmitterPtr.Get() != NULL) && (type == NFC_TARGET_TYPE))){
288                 EventNFCType nfcType = type;
289
290                 if ((props != NULL) && (type == NFC_TAG_TYPE)) {
291
292                         nfc_tag_type_e tagType;
293
294                         if (nfc_tag_get_type((nfc_tag_h)props, &tagType) == NFC_ERROR_NONE) {
295                                 LogDebug("NFCManager::NFCHasDetected Tag real type : " << tagType);
296                                                                         int cnt;
297                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize() ; cnt++) {
298                                         NFCUtil Util;
299                                         if (Util.convertTonfcTagType(static_cast<unsigned short>(tagType)) == m_tagFilter->getFilterValue(cnt))
300                                                 break;
301                                 }
302                                 if ((m_tagFilter->getFilterSize() > 0) && (cnt == m_tagFilter->getFilterSize())) {
303                                         LogDebug("Filter doesn't have this tag type ");
304                                         return;
305                                 }
306
307                                 switch(tagType) {
308                                         case NFC_MIFARE_MINI_PICC:
309                                         case NFC_MIFARE_1K_PICC:
310                                         case NFC_MIFARE_4K_PICC:
311                                                 nfcType = NFC_TAG_MIFARE_CLASSIC_TYPE;
312                                                 break;
313                                         case NFC_MIFARE_ULTRA_PICC:
314                                                 nfcType = NFC_TAG_MIFARE_ULTRA_TYPE;
315                                                 break;
316                                         default:
317                                                 nfcType = NFC_TAG_TYPE;
318                                                 break;
319                                 }
320                         } else {
321                                 LogDebug("It can't get real nfc tag type");
322                                 int cnt;
323                                 for (cnt = 0; cnt < m_tagFilter->getFilterSize() ; cnt++) {
324                                         if (NFC_TAGTYPE_GENERIC_PICC == m_tagFilter->getFilterValue(cnt))
325                                                 break;
326                                 }
327
328                                 if (cnt == m_tagFilter->getFilterSize()) {
329                                         LogDebug("Filter doesn't have this tag type ");
330                                         return;
331                                 }
332
333                         }
334                 }
335
336                 EventNFCChangedPtr event( new EventNFCChanged() );
337                 LogDebug("nfc type was detected");
338                 if (props == NULL)
339                         event->setNFCStatus(NFC_DETATCHED);
340                 else
341                         event->setNFCStatus(NFC_ATTATCHED);
342                 event->setNFCProperties(props);
343                 event->setNFCType(nfcType);
344                 event->setPrivateNFCManagerPtr(m_managerPriv);
345                 LogDebug("emit event with nfc tag info");
346                 if (type == NFC_TARGET_TYPE)
347                         m_NFCTargetEmitterPtr->emit(event);
348                 else
349                         m_NFCTagEmitterPtr->emit(event);
350         } else {
351                 LogDebug("m_NFCTagEmitterPtr.Get() != NULL ? " << (m_NFCTagEmitterPtr.Get() != NULL));
352         }
353
354
355 }
356
357 void NFCManager::NDEFHasDetected(std::vector<unsigned char> data)
358 {
359         LogDebug("NFCManager::NFCHasDetected Enter");
360
361         if (m_NdefEmitterPtr.Get() != NULL) {
362                 EventNFCChangedNdefPtr event( new EventNFCChangedNdef() );
363                 LogDebug("nfc type was detected");
364
365                 event->setReadNdefResult(data);
366                 LogDebug("emit event with nfc tag info");
367                 m_NdefEmitterPtr->emit(event);
368         }
369 }
370
371 void NFCManager::SeEventHasDetected(nfcSeEventType eventType)
372 {
373         LogDebug("NDEF is detected Enter");
374
375         if (m_SeEventEmitterPtr.Get() != NULL) {
376                 EventNFCChangedSeEventPtr event( new EventNFCChangedSeEvent() );
377                 event->setSeEvent(eventType);
378                 m_SeEventEmitterPtr->emit(event);
379         }
380 }
381
382 void NFCManager::initialize() {
383         LogDebug("NFCManager::initialize Entered");
384         int result = -1;
385         result = nfc_manager_initialize();
386         if (result != NFC_ERROR_NONE) {
387                 LogError("Could not initialize NFC.");
388                 Throw(WrtDeviceApis::Commons::UnsupportedException);
389                 m_initialized = false;
390         }
391         m_initialized = true;
392         return;
393 }
394
395 void *NFCManager::getCachedMessage() {
396         LogDebug("Entered");
397         nfc_ndef_message_h messageHandle;
398         int result = nfc_manager_get_cached_message(&messageHandle);
399         if (result == NFC_ERROR_INVALID_NDEF_MESSAGE)
400                 return NULL;
401         if (result != NFC_ERROR_NONE)
402                 ThrowMsg(PlatformException, "Can't get cached message");
403
404         return (void *)(messageHandle);
405 }
406
407 bool NFCManager::isValidHandle(void * handle) {
408         LogDebug("Entered");
409         if ((handle != NULL) && (handle == curHandle))
410                 return TRUE;
411
412         return FALSE;
413 }
414
415 void NFCManager::updateCurrentHandle(void *handle) {
416         LogDebug("Updated!");
417         curHandle = handle;
418 }
419
420 }
421 }
422 }