src/Tizen.Network.Nfc/Tizen.Network.Nfc/NfcEventArgs.cs

   1 /*
   2  * Copyright (c) 2016 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 using System;
  18 using System.Collections.Generic;
  19
  20 namespace Tizen.Network.Nfc
  21 {
  22     /// <summary>
  23     /// An extended EventArgs class which contains changed Nfc activation state.
  24     /// </summary>
  25     /// <since_tizen> 3 </since_tizen>
  26     public class ActivationChangedEventArgs : EventArgs
  27     {
  28         private bool _activated = false;
  29
  30         internal ActivationChangedEventArgs(bool activated)
  31         {
  32             _activated = activated;
  33         }
  34
  35         /// <summary>
  36         /// The Nfc activation state.
  37         /// </summary>
  38         /// <since_tizen> 3 </since_tizen>
  39         public bool Activated
  40         {
  41             get
  42             {
  43                 return _activated;
  44             }
  45         }
  46     }
  47
  48     /// <summary>
  49     /// An extended EventArgs class which contains changed Nfc tag discovered.
  50     /// </summary>
  51     /// <since_tizen> 3 </since_tizen>
  52     public class TagDiscoveredEventArgs : EventArgs
  53     {
  54         private NfcDiscoveredType _type = NfcDiscoveredType.Detached;
  55         private NfcTag _tag;
  56
  57         internal TagDiscoveredEventArgs(NfcDiscoveredType _type, IntPtr tagHandle)
  58         {
  59             _tag = new NfcTag(tagHandle);
  60         }
  61
  62         /// <summary>
  63         /// The tag type.
  64         /// </summary>
  65         /// <since_tizen> 3 </since_tizen>
  66         public NfcDiscoveredType Type
  67         {
  68             get
  69             {
  70                 return _type;
  71             }
  72         }
  73
  74         /// <summary>
  75         /// Tag object
  76         /// </summary>
  77         /// <since_tizen> 3 </since_tizen>
  78         public NfcTag Tag
  79         {
  80             get
  81             {
  82                 return _tag;
  83             }
  84         }
  85     }
  86
  87     /// <summary>
  88     /// An extended EventArgs class which contains changed Nfc p2p target discovered.
  89     /// </summary>
  90     /// <since_tizen> 3 </since_tizen>
  91     public class P2pTargetDiscoveredEventArgs : EventArgs
  92     {
  93         private NfcDiscoveredType _type = NfcDiscoveredType.Detached;
  94         private NfcP2p _p2pTarget;
  95
  96         internal P2pTargetDiscoveredEventArgs(NfcDiscoveredType _type, IntPtr p2pTargetHandle)
  97         {
  98             _p2pTarget = new NfcP2p(p2pTargetHandle);
  99         }
 100
 101         /// <summary>
 102         /// The p2p target type.
 103         /// </summary>
 104         /// <since_tizen> 3 </since_tizen>
 105         public NfcDiscoveredType Type
 106         {
 107             get
 108             {
 109                 return _type;
 110             }
 111         }
 112
 113         /// <summary>
 114         /// P2p object
 115         /// </summary>
 116         /// <since_tizen> 3 </since_tizen>
 117         public NfcP2p P2pTarget
 118         {
 119             get
 120             {
 121                 return _p2pTarget;
 122             }
 123         }
 124     }
 125
 126     /// <summary>
 127     /// An extended EventArgs class which contains changed Nfc ndef discovered.
 128     /// </summary>
 129     /// <since_tizen> 3 </since_tizen>
 130     public class NdefMessageDiscoveredEventArgs : EventArgs
 131     {
 132         private NfcNdefMessage _ndef;
 133
 134         internal NdefMessageDiscoveredEventArgs(IntPtr messageHandle)
 135         {
 136             _ndef = new NfcNdefMessage(messageHandle);
 137         }
 138
 139         /// <summary>
 140         /// The NdefMessage object that is most recently received via NFC p2p mode or tag mode
 141         /// </summary>
 142         /// <since_tizen> 3 </since_tizen>
 143         public NfcNdefMessage NdefMessage
 144         {
 145             get
 146             {
 147                 return _ndef;
 148             }
 149         }
 150     }
 151
 152     /// <summary>
 153     /// An extended EventArgs class which contains changed Secure element event.
 154     /// </summary>
 155     /// <since_tizen> 3 </since_tizen>
 156     public class SecureElementEventArgs : EventArgs
 157     {
 158         private NfcSecureElementEvent _eventType = NfcSecureElementEvent.StartTransaction;
 159
 160         internal SecureElementEventArgs(NfcSecureElementEvent eventType)
 161         {
 162             _eventType = eventType;
 163         }
 164
 165         /// <summary>
 166         /// The Nfc secure element event.
 167         /// </summary>
 168         /// <since_tizen> 3 </since_tizen>
 169         public NfcSecureElementEvent EventType
 170         {
 171             get
 172             {
 173                 return _eventType;
 174             }
 175         }
 176     }
 177
 178     /// <summary>
 179     /// An extended EventArgs class which contains changed Secure element trasaction event.
 180     /// </summary>
 181     /// <since_tizen> 3 </since_tizen>
 182     public class SecureElementTranscationEventArgs : EventArgs
 183     {
 184         private NfcSecureElementType _secureElementType = NfcSecureElementType.Disable;
 185         byte[] _aid;
 186         byte[] _param;
 187
 188         internal SecureElementTranscationEventArgs(NfcSecureElementType secureElementType, byte[] aid, byte[] param)
 189         {
 190             _secureElementType = secureElementType;
 191             _aid = aid;
 192             _param = param;
 193         }
 194
 195         /// <summary>
 196         /// The Nfc secure element type.
 197         /// </summary>
 198         /// <since_tizen> 3 </since_tizen>
 199         public NfcSecureElementType SecureElementType
 200         {
 201             get
 202             {
 203                 return _secureElementType;
 204             }
 205         }
 206         /// <summary>
 207         /// The Nfc secure element aid.
 208         /// </summary>
 209         /// <since_tizen> 3 </since_tizen>
 210         public byte[] ApplicationID
 211         {
 212             get
 213             {
 214                 return _aid;
 215             }
 216         }
 217         /// <summary>
 218         /// The Nfc secure element param.
 219         /// </summary>
 220         /// <since_tizen> 3 </since_tizen>
 221         public byte[] Param
 222         {
 223             get
 224             {
 225                 return _param;
 226             }
 227         }
 228     }
 229
 230     /// <summary>
 231     /// An extended EventArgs class which contains changed HCE(Host Card Emulation) event.
 232     /// </summary>
 233     /// <since_tizen> 3 </since_tizen>
 234     public class HostCardEmulationEventArgs : EventArgs
 235     {
 236         private NfcSecureElement _se;
 237         private NfcHceEvent _hceEvent = NfcHceEvent.Deactivated;
 238         private byte[] _apdu;
 239
 240         internal HostCardEmulationEventArgs(IntPtr seHandle, NfcHceEvent hcdEvent, byte[] apdu)
 241         {
 242             _se = new NfcSecureElement(seHandle);
 243             _hceEvent = hcdEvent;
 244             _apdu = apdu;
 245         }
 246
 247         /// <summary>
 248         /// The Nfc secure element.
 249         /// </summary>
 250         /// <since_tizen> 3 </since_tizen>
 251         public NfcSecureElement SecureElement
 252         {
 253             get
 254             {
 255                 return _se;
 256             }
 257         }
 258         /// <summary>
 259         /// The Nfc hce event.
 260         /// </summary>
 261         /// <since_tizen> 3 </since_tizen>
 262         public NfcHceEvent HceEvent
 263         {
 264             get
 265             {
 266                 return _hceEvent;
 267             }
 268         }
 269         /// <summary>
 270         /// The Nfc apdu(Application Protocol Data Unit)
 271         /// </summary>
 272         /// <since_tizen> 3 </since_tizen>
 273         public byte[] Apdu
 274         {
 275             get
 276             {
 277                 return _apdu;
 278             }
 279         }
 280     }
 281
 282     /// <summary>
 283     /// An extended EventArgs class which contains changed HCE(Host Card Emulation) event.
 284     /// </summary>
 285     /// <since_tizen> 3 </since_tizen>
 286     public class P2pDataReceivedEventArgs : EventArgs
 287     {
 288         private NfcP2p _p2pTarget;
 289         private NfcNdefMessage _ndefMessage;
 290
 291         internal P2pDataReceivedEventArgs(IntPtr p2pHandle, IntPtr ndefHandle)
 292         {
 293             _p2pTarget = new NfcP2p(p2pHandle);
 294             _ndefMessage = new NfcNdefMessage(ndefHandle);
 295         }
 296
 297         /// <summary>
 298         /// The Nfc p2p target.
 299         /// </summary>
 300         /// <since_tizen> 3 </since_tizen>
 301         public NfcP2p P2pTarget
 302         {
 303             get
 304             {
 305                 return _p2pTarget;
 306             }
 307         }
 308         /// <summary>
 309         /// The Nfc ndef message.
 310         /// </summary>
 311         /// <since_tizen> 3 </since_tizen>
 312         public NfcNdefMessage NdefMessage
 313         {
 314             get
 315             {
 316                 return _ndefMessage;
 317             }
 318         }
 319     }
 320 }