Package apple.foundation

Class NSURLSessionStreamTask

  • All Implemented Interfaces:
    NSCopying, NSProgressReporting, NSObject
    public class NSURLSessionStreamTask
extends NSURLSessionTask
    An NSURLSessionStreamTask provides an interface to perform reads and writes to a TCP/IP stream created via NSURLSession. This task may be explicitly created from an NSURLSession, or created as a result of the appropriate disposition response to a -URLSession:dataTask:didReceiveResponse: delegate message. NSURLSessionStreamTask can be used to perform asynchronous reads and writes. Reads and writes are enquened and executed serially, with the completion handler being invoked on the sessions delegate queuee. If an error occurs, or the task is canceled, all outstanding read and write calls will have their completion handlers invoked with an appropriate error. It is also possible to create NSInputStream and NSOutputStream instances from an NSURLSessionTask by sending -captureStreams to the task. All outstanding read and writess are completed before the streams are created. Once the streams are delivered to the session delegate, the task is considered complete and will receive no more messsages. These streams are disassociated from the underlying session.

    • Constructor Detail

      • NSURLSessionStreamTask

        protected NSURLSessionStreamTask​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • allocWithZone

        public static java.lang.Object allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(java.lang.Object aTarget,
                                                                         org.moe.natj.objc.SEL aSelector,
                                                                         java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        public static NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        public static org.moe.natj.objc.Class classForKeyedUnarchiver()

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • hash_static

        public static long hash_static()

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • keyPathsForValuesAffectingValueForKey

        public static NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(java.lang.String key)

      • new_objc

        public static java.lang.Object new_objc()

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • version_static

        public static long version_static()

      • captureStreams

        public void captureStreams()
        -captureStreams completes any already enqueued reads and writes, and then invokes the URLSession:streamTask:didBecomeInputStream:outputStream: delegate message. When that message is received, the task object is considered completed and will not receive any more delegate messages.

      • closeRead

        public void closeRead()
        Enqueue a request to close the read side of the underlying socket. All outstanding IO will complete before the read side is closed. You may continue writing to the server.

      • closeWrite

        public void closeWrite()
        Enqueue a request to close the write end of the underlying socket. All outstanding IO will complete before the write side of the socket is closed. The server, however, may continue to write bytes back to the client, so best practice is to continue reading from the server until you receive EOF.

      • readDataOfMinLengthMaxLengthTimeoutCompletionHandler

        public void readDataOfMinLengthMaxLengthTimeoutCompletionHandler​(long minBytes,
                                                                 long maxBytes,
                                                                 double timeout,
                                                                 NSURLSessionStreamTask.Block_readDataOfMinLengthMaxLengthTimeoutCompletionHandler completionHandler)
        Read minBytes, or at most maxBytes bytes and invoke the completion handler on the sessions delegate queue with the data or an error. If an error occurs, any outstanding reads will also fail, and new read requests will error out immediately.

      • startSecureConnection

        public void startSecureConnection()
        Begin encrypted handshake. The hanshake begins after all pending IO has completed. TLS authentication callbacks are sent to the session's -URLSession:task:didReceiveChallenge:completionHandler:

      • stopSecureConnection

        public void stopSecureConnection()
        Cleanly close a secure connection after all pending secure IO has completed. [@warning] This API is non-functional.

      • writeDataTimeoutCompletionHandler

        public void writeDataTimeoutCompletionHandler​(NSData data,
                                              double timeout,
                                              NSURLSessionStreamTask.Block_writeDataTimeoutCompletionHandler completionHandler)
        Write the data completely to the underlying socket. If all the bytes have not been written by the timeout, a timeout error will occur. Note that invocation of the completion handler does not guarantee that the remote side has received all the bytes, only that they have been written to the kernel.