Struct TKSmartCardTokenSession

Source

pub struct TKSmartCardTokenSession { /* private fields */ }

Available on crate features TKSmartCardToken and TKToken only.

Expand description

TKSmartCardTokenSession represents token session based on SmartCard token.

When implementing SmartCard token extension, subclass TKSmartCardTokenSession and implement TKTokenSessionDelegate on it. Use #token property to get access and send APDUs to the underlying SmartCard.

Implementations§

Source §

impl TKSmartCardTokenSession

Source

pub unsafe fn smartCard(&self) -> Retained<TKSmartCard>

👎Deprecated

Available on crate feature TKSmartCard only.

contains TKSmartCard instance with active exclusive session and SmartCard application selected.

This property can be accessed only when handling one of the methods of TKTokenSessionDelegate protocol. If associated token has set AID property, then the returned card has opened exclusive session to the card and the application is already selected. Therefore there is no need to call -[TKSmartCard beginSessionWithReply:]) on returned SmartCard instance in such case and system will take care of terminating session when current token request servicing is finished, -[TKSmartCard endSession] must not be called either.

You can store any kind of context state information representing state of the card into smartCard.context property. This property will be automatically set to nil if the card is reset or accessed by different TKSmartCard instance (possibly in another process). Checking TKSmartCard.context property for previously stored value can be used to avoid potentially costly restoring of SmartCard state before performing the operation.

Source

pub unsafe fn getSmartCardWithError( &self, ) -> Result<Retained<TKSmartCard>, Retained<NSError>>

Available on crate feature TKSmartCard only.

Returns a TKSmartCard instance with an active exclusive session and the SmartCard application selected. Replaces the deprecated smartCardproperty.

The TKSmartCard object is only accessible within the methods of the TKTokenSessionDelegate protocol. If the associated token has an AID set, the returned card will have an exclusive session already opened and the specified application selected. In this scenario: Do not call -[TKSmartCard beginSessionWithReply:]) on the returned SmartCard instance. The system manages the session lifecycle and will terminate it automatically when the current token request servicing is finished. Do not call -[TKSmartCard endSession]. You can use the smartCard.context property to store any context-specific state information related to the card. This property is automatically set to nil if the card is reset or accessed by a different TKSmartCard instance (potentially in another process). Before performing an operation, check the TKSmartCard.context property for a previously stored value. This can help you avoid potentially costly restoration of the SmartCard state if it’s already available.

Parameter error: An NSError object containing details if the operation fails.

Source §

impl TKSmartCardTokenSession

Methods declared on superclass TKTokenSession.

Source

pub unsafe fn initWithToken( this: Allocated<Self>, token: &TKToken, ) -> Retained<Self>

Parameter token: Token instance to which is this session instance bound.

Source

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

Source §

impl TKSmartCardTokenSession

Methods declared on superclass NSObject.

Source

pub unsafe fn new() -> Retained<Self>

Methods from Deref<Target = TKTokenSession>§

Source

pub unsafe fn token(&self) -> Retained<TKToken>

Source

pub unsafe fn delegate( &self, ) -> Option<Retained<ProtocolObject<dyn TKTokenSessionDelegate>>>

Source

pub unsafe fn setDelegate( &self, delegate: Option<&ProtocolObject<dyn TKTokenSessionDelegate>>, )

Setter for delegate.

This is a weak property.

Methods from Deref<Target = NSObject>§

Source

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>§

Source

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

§Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

§Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

Source

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T
where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

§Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

Source

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

§Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

§Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

§Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

§Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}