/// <summary> /// Transceives the data of the raw format card. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="buffer">The binary data for a parameter or additional commands.</param> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the the method fails due to an invalid operation.</exception> public Task <byte[]> TransceiveAsync(byte[] buffer) { var task = new TaskCompletionSource <byte[]>(); byte[] resultBuffer = null; Interop.Nfc.TagTransceiveCompletedCallback callback = (int result, IntPtr resultData, int dataSize, IntPtr userData) => { if (result == (int)NfcError.None) { resultBuffer = new byte[dataSize]; Marshal.Copy(resultData, resultBuffer, 0, dataSize); task.SetResult(resultBuffer); } return; }; int ret = Interop.Nfc.Tag.Transceive(_tagHandle, buffer, buffer.Length, callback, IntPtr.Zero); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to transceive data, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } return(task.Task); }
/// <summary> /// Retrieves all the tag information. /// </summary> /// <since_tizen> 3 </since_tizen> /// <returns>The list of the NfcTagInformation objects.</returns> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public IEnumerable <NfcTagInformation> ForeachInformation() { List <NfcTagInformation> infoList = new List <NfcTagInformation>(); Interop.Nfc.TagInformationCallback callback = (IntPtr key, IntPtr infoValue, int valueSize, IntPtr userData) => { if (key != IntPtr.Zero && infoValue != IntPtr.Zero) { NfcTagInformation tagInfo = new NfcTagInformation(Marshal.PtrToStringAnsi(key), new byte[valueSize]); Marshal.Copy(infoValue, tagInfo.InformationValue, 0, valueSize); infoList.Add(tagInfo); return(true); } return(false); }; int ret = Interop.Nfc.Tag.ForeachInformation(_tagHandle, callback, IntPtr.Zero); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to get all Tag information, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } return(infoList); }
/// <summary> /// Reads the NDEF formatted data from the NFC tag. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public Task <NfcNdefMessage> ReadNdefMessageAsync() { var task = new TaskCompletionSource <NfcNdefMessage>(); NfcNdefMessage ndefMsg = null; Interop.Nfc.TagReadCompletedCallback callback = (int result, IntPtr ndefMessage, IntPtr userData) => { if (result == (int)NfcError.None) { ndefMsg = new NfcNdefMessage(ndefMessage); task.SetResult(ndefMsg); return(true); } return(false); }; int ret = Interop.Nfc.Tag.ReadNdef(_tagHandle, callback, IntPtr.Zero); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to read ndef message, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } return(task.Task); }
internal Task SetActivationAsync(bool activation) { TaskCompletionSource <bool> task = new TaskCompletionSource <bool>(); IntPtr id = IntPtr.Zero; lock (_callback_map) { id = (IntPtr)_requestId++; _callback_map[id] = (error, key) => { Log.Debug(Globals.LogTag, "nfc activated"); if (error != (int)NfcError.None) { Log.Error(Globals.LogTag, "Error occurs during Nfc activating, " + (NfcError)error); task.SetException(new InvalidOperationException("Error occurs during Nfc activating, " + (NfcError)error)); } task.SetResult(true); lock (_callback_map) { _callback_map.Remove(key); } }; int ret = Interop.Nfc.SetActivation(activation, _callback_map[id], id); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to activate nfc, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } } return(task.Task); }
/// <summary> /// Unsets the application as a preferred handler. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege>http://tizen.org/privilege/nfc.cardemulation</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public void UnsetPreferredApplication() { int ret = Interop.Nfc.CardEmulation.UnsetPreferredHandler(); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to unset preferred handler, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Unregisters a previously registered AID for the specified category. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="seType">The type of the secure element.</param> /// <param name="category">Enumeration value of the category.</param> /// <param name="aid">The application ID specified in the ISO/IEC 7816-4.</param> /// <privilege>http://tizen.org/privilege/nfc.cardemulation</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public void UnregisterAid(NfcSecureElementType seType, NfcCardEmulationCategoryType category, string aid) { int ret = Interop.Nfc.CardEmulation.UnregisterAid((int)seType, (int)category, aid); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to unregister aid, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Disables the foreground dispatch for the "EVT_TRANSACTION" to the given application. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege>http://tizen.org/privilege/nfc.cardemulation</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public void DisableTransactionForegroundDispatch() { int ret = Interop.Nfc.DisableTransactionForegroundDispatch(); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to disable foreground dispatch, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Disables the card emulation mode. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege>http://tizen.org/privilege/nfc.cardemulation</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public void DisableCardEmulation() { int ret = Interop.Nfc.CardEmulation.DisableCardEmulatiion(); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to disable card emulation mode, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Creates a record with the mime type payload. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="mimeType">The mime type [RFC 2046] \(ex. text/plain, image/jpeg ). This value is stored in the type field.</param> /// <param name="data">The data in the form of the bytes array.</param> /// <param name="dataSize">The size of the data.</param> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public NfcNdefRecord(string mimeType, byte[] data, uint dataSize) { int ret = Interop.Nfc.NdefRecord.CreateMime(out _recordHandle, mimeType, data, dataSize); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to create ndef Mime record, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Creates a record with the URI type payload. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="uri">The URI string that will be stored in the payload.</param> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public NfcNdefRecord(string uri) { int ret = Interop.Nfc.NdefRecord.CreateUri(out _recordHandle, uri); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to create ndef Uri record, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Creates a record with the text type payload. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="text">The encoded text.</param> /// <param name="languageCode">The language code string value followed by the IANA [RFC 3066] \(ex: en-US, ko-KR).</param> /// <param name="encode">The encoding type.</param> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public NfcNdefRecord(string text, string languageCode, NfcEncodeType encode) { int ret = Interop.Nfc.NdefRecord.CreateText(out _recordHandle, text, languageCode, (int)encode); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to create ndef Text record, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Creates a record with a given parameter value. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="format">The type name format.</param> /// <param name="type">The specified type name.</param> /// <param name="id">The record ID.</param> /// <param name="payload">The payload of this record.</param> /// <param name="paloadLength">The byte size of the payload.</param> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public NfcNdefRecord(NfcRecordTypeNameFormat format, byte[] type, byte[] id, byte[] payload, uint paloadLength) { int ret = Interop.Nfc.NdefRecord.Create(out _recordHandle, (int)format, type, type.Length, id, id.Length, payload, paloadLength); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to create Ndef record, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Sends the APDU (Application Protocol Data Unit) response to the CLF (Contactless Front-end). /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="response">The bytes array of the response data.</param> /// <param name="responseLength">The size of the response bytes array.</param> /// <privilege>http://tizen.org/privilege/nfc.cardemulation</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public void HceSendApduResponse(byte[] response, uint responseLength) { int ret = Interop.Nfc.CardEmulation.HceSendApduRespondse(_secureElementHandle, response, responseLength); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to hcd send apdu response, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Creates an object for the access point. /// </summary> /// <since_tizen> 3 </since_tizen> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public NfcNdefMessage() { int ret = Interop.Nfc.NdefMessage.Create(out _messageHandle); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to create Ndef message, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
private void Initialize() { int ret = Interop.Nfc.Initialize(); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to Initialize Nfc, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Gets the state, whether an application to call this API is currently the activated handler for the category. /// </summary> /// <since_tizen> 3 </since_tizen> /// <returns>'True' when application is currently the activated handler, otherwise 'False'.</returns> /// <param name="seType">The type of the secure element.</param> /// <param name="category">Enumeration value of the category.</param> /// <privilege>http://tizen.org/privilege/nfc.cardemulation</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public bool IsActivatedHandlerForCategory(NfcSecureElementType seType, NfcCardEmulationCategoryType category) { bool isActivatedHandle = false; int ret = Interop.Nfc.CardEmulation.IsActivatedHandlerForCategory((int)seType, (int)category, out isActivatedHandle); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to check activated handle for category, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } return(isActivatedHandle); }
/// <summary> /// Gets the current connected P2P target. /// </summary> /// <since_tizen> 3 </since_tizen> /// <returns>The NfcP2p object.</returns> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public NfcP2p GetConnectedTarget() { IntPtr targetHandle = IntPtr.Zero; int ret = Interop.Nfc.GetConnectedTarget(out targetHandle); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to get connected p2p target, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } _p2pTarget = new NfcP2p(targetHandle); return(_p2pTarget); }
/// <summary> /// Gets the current connected tag. /// </summary> /// <since_tizen> 3 </since_tizen> /// <returns>The NfcTag object.</returns> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public NfcTag GetConnectedTag() { IntPtr tagHandle = IntPtr.Zero; int ret = Interop.Nfc.GetConnectedTag(out tagHandle); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to get connected tag, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } _tag = new NfcTag(tagHandle); return(_tag); }
private void RegisterHostCardEmulationEvent() { _hostCardEmulationEventCallback = (IntPtr handle, int eventType, IntPtr apdu, uint apduLen, IntPtr userData) => { IntPtr _seHandle = handle; NfcHceEvent _hcdEventType = (NfcHceEvent)eventType; byte[] _apdu = NfcConvertUtil.UintLengthIntPtrToByteArray(apdu, apduLen); HostCardEmulationEventArgs e = new HostCardEmulationEventArgs(_seHandle, _hcdEventType, _apdu); _hostCardEmulationEvent.SafeInvoke(null, e); }; int ret = Interop.Nfc.SetHostCardEmulationEventCallback(_hostCardEmulationEventCallback, IntPtr.Zero); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to set host card emulation event callback, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } }
/// <summary> /// Formats the detected tag that can store the NDEF message. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="keyValue">The key value that may need to format the tag.</param> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public Task <NfcError> FormatNdefMessageAsync(byte[] keyValue) { var task = new TaskCompletionSource <NfcError>(); Interop.Nfc.VoidCallback callback = (int result, IntPtr userData) => { task.SetResult((NfcError)result); return; }; int ret = Interop.Nfc.Tag.FormatNdef(_tagHandle, keyValue, keyValue.Length, callback, IntPtr.Zero); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to format ndef message, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } return(task.Task); }
/// <summary> /// Writes the NDEF formatted data. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="ndefMessage">The NfcNdefMessage object.</param> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public Task <NfcError> WriteNdefMessageAsync(NfcNdefMessage ndefMessage) { var task = new TaskCompletionSource <NfcError>(); Interop.Nfc.VoidCallback callback = (int result, IntPtr userData) => { task.SetResult((NfcError)result); return; }; int ret = Interop.Nfc.Tag.WriteNdef(_tagHandle, ndefMessage.GetHandle(), callback, IntPtr.Zero); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to write ndef message, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } return(task.Task); }
/// <summary> /// Reads the NDEF formatted data from the NFC tag. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public Task <NfcNdefMessage> ReadNdefMessageAsync() { int requestId = 0; var task = new TaskCompletionSource <NfcNdefMessage>(); lock (this) { requestId = _requestId++; _readNdefTaskSource[requestId] = task; } int ret = Interop.Nfc.Tag.ReadNdef(_tagHandle, _nativeTagReadCallback, (IntPtr)requestId); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to read ndef message, Error - " + (NfcError)ret); _readNdefTaskSource.Remove(requestId); NfcErrorFactory.ThrowNfcException(ret); } return(task.Task); }
/// <summary> /// Transceives the data of the raw format card. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="buffer">The binary data for a parameter or additional commands.</param> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the the method fails due to an invalid operation.</exception> public Task <byte[]> TransceiveAsync(byte[] buffer) { int requestId = 0; var task = new TaskCompletionSource <byte[]>(); lock (this) { requestId = _requestId++; _transceiveTaskSource[requestId] = task; } int ret = Interop.Nfc.Tag.Transceive(_tagHandle, buffer, buffer.Length, _nativeTransceiveCallback, (IntPtr)requestId); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to transceive data, Error - " + (NfcError)ret); _transceiveTaskSource.Remove(requestId); NfcErrorFactory.ThrowNfcException(ret); } return(task.Task); }
/// <summary> /// Formats the detected tag that can store the NDEF message. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="keyValue">The key value that may need to format the tag.</param> /// <privilege>http://tizen.org/privilege/nfc</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public Task <NfcError> FormatNdefMessageAsync(byte[] keyValue) { int requestId = 0; var task = new TaskCompletionSource <NfcError>(); lock (this) { requestId = _requestId++; _voidTaskSource[requestId] = task; } int ret = Interop.Nfc.Tag.FormatNdef(_tagHandle, keyValue, keyValue.Length, _nativeVoidCallback, (IntPtr)requestId); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to format ndef message, Error - " + (NfcError)ret); _voidTaskSource.Remove(requestId); NfcErrorFactory.ThrowNfcException(ret); } return(task.Task); }
/// <summary> /// Retrieves all registered AIDs. /// </summary> /// <since_tizen> 3 </since_tizen> /// <returns>The list of NfcRegisteredAidInformation objects.</returns> /// <param name="seType">The type of the secure element.</param> /// <param name="category">Enumeration value of the category.</param> /// <privilege>http://tizen.org/privilege/nfc.cardemulation</privilege> /// <exception cref="NotSupportedException">Thrown when the NFC is not supported.</exception> /// <exception cref="ArgumentException">Thrown when the method fails due to an invalid parameter.</exception> /// <exception cref="InvalidOperationException">Thrown when the method fails due to an invalid operation.</exception> public IEnumerable <NfcRegisteredAidInformation> GetRegisteredAidInformation(NfcSecureElementType seType, NfcCardEmulationCategoryType category) { List <NfcRegisteredAidInformation> infoList = new List <NfcRegisteredAidInformation>(); Interop.Nfc.SecureElementRegisteredAidCallback callback = (int type, IntPtr aid, bool readOnly, IntPtr userData) => { if (aid != IntPtr.Zero) { NfcRegisteredAidInformation aidInfo = new NfcRegisteredAidInformation((NfcSecureElementType)type, Marshal.PtrToStringAnsi(aid), readOnly); infoList.Add(aidInfo); } }; int ret = Interop.Nfc.CardEmulation.ForeachRegisterdAids((int)seType, (int)category, callback, IntPtr.Zero); if (ret != (int)NfcError.None) { Log.Error(Globals.LogTag, "Failed to get all registerd aid informations, Error - " + (NfcError)ret); NfcErrorFactory.ThrowNfcException(ret); } return(infoList); }