watchOS WCSession 'gepaart' und 'watchAppAvailable' sind nicht verfügbar

Question

Ich versuche, ein Singleton zu verwenden, um WCSession-Nachrichten zu verwalten, die ich here gefunden habe.

Ich verstehe, was es zu tun versucht, aber ich verstehe nicht, warum ich eine Störung erhalte ... das ist die Linie, mit denen ich zu kämpfen:

if let session = session where session.paired && session.watchAppInstalled { 

Fehler: ‚watchAppInstalled‘ nicht verfügbar ist

Fehler: 'gepaart' ist nicht zugänglich

Frage: Wie kann ich diese Eigenschaften ein verfügbar? Neu bei watchOS und ios im Allgemeinen. Vielen Dank!

Entire Code:

import WatchConnectivity 

class WatchSessionManager: NSObject, WCSessionDelegate { 

    static let sharedManager = WatchSessionManager() 
    private override init() { 
     super.init() 
    } 

    private let session: WCSession? = WCSession.isSupported() ? WCSession.defaultSession() : nil 

    private var validSession: WCSession? { 

     // paired - the user has to have their device paired to the watch 
     // watchAppInstalled - the user must have your watch app installed 

     // Note: if the device is paired, but your watch app is not installed 
     // consider prompting the user to install it for a better experience 

     if let session = session where session.paired && session.watchAppInstalled { 
      return session 
     } 
     return nil 
    } 

    func startSession() { 
     session?.delegate = self 
     session?.activateSession() 
    } 
} 

// MARK: Application Context 
// use when your app needs only the latest information 
// if the data was not sent, it will be replaced 
extension WatchSessionManager { 

    // Sender 
    func updateApplicationContext(applicationContext: [String : AnyObject]) throws { 
     if let session = validSession { 
      do { 
       try session.updateApplicationContext(applicationContext) 
      } catch let error { 
       throw error 
      } 
     } 
    } 

    // Receiver 
    func session(session: WCSession, didReceiveApplicationContext applicationContext: [String : AnyObject]) { 
     // handle receiving application context 

     dispatch_async(dispatch_get_main_queue()) { 
      // make sure to put on the main queue to update UI! 
     } 
    } 
} 

// MARK: User Info 
// use when your app needs all the data 
// FIFO queue 
extension WatchSessionManager { 

    // Sender 
    func transferUserInfo(userInfo: [String : AnyObject]) -> WCSessionUserInfoTransfer? { 
     return validSession?.transferUserInfo(userInfo) 
    } 

    func session(session: WCSession, didFinishUserInfoTransfer userInfoTransfer: WCSessionUserInfoTransfer, error: NSError?) { 
     // implement this on the sender if you need to confirm that 
     // the user info did in fact transfer 
    } 

    // Receiver 
    func session(session: WCSession, didReceiveUserInfo userInfo: [String : AnyObject]) { 
     // handle receiving user info 
     dispatch_async(dispatch_get_main_queue()) { 
      // make sure to put on the main queue to update UI! 
     } 
    } 

} 

// MARK: Transfer File 
extension WatchSessionManager { 

    // Sender 
    func transferFile(file: NSURL, metadata: [String : AnyObject]) -> WCSessionFileTransfer? { 
     return validSession?.transferFile(file, metadata: metadata) 
    } 

    func session(session: WCSession, didFinishFileTransfer fileTransfer: WCSessionFileTransfer, error: NSError?) { 
     // handle filed transfer completion 
    } 

    // Receiver 
    func session(session: WCSession, didReceiveFile file: WCSessionFile) { 
     // handle receiving file 
     dispatch_async(dispatch_get_main_queue()) { 
      // make sure to put on the main queue to update UI! 
     } 
    } 
} 


// MARK: Interactive Messaging 
extension WatchSessionManager { 

    // Live messaging! App has to be reachable 
    private var validReachableSession: WCSession? { 
     if let session = validSession where session.reachable { 
      return session 
     } 
     return nil 
    } 

    // Sender 
    func sendMessage(message: [String : AnyObject], 
     replyHandler: (([String : AnyObject]) -> Void)? = nil, 
     errorHandler: ((NSError) -> Void)? = nil) 
    { 
     validReachableSession?.sendMessage(message, replyHandler: replyHandler, errorHandler: errorHandler) 
    } 

    func sendMessageData(data: NSData, 
     replyHandler: ((NSData) -> Void)? = nil, 
     errorHandler: ((NSError) -> Void)? = nil) 
    { 
     validReachableSession?.sendMessageData(data, replyHandler: replyHandler, errorHandler: errorHandler) 
    } 

    // Receiver 
    func session(session: WCSession, didReceiveMessage message: [String : AnyObject], replyHandler: ([String : AnyObject]) -> Void) { 
     // handle receiving message 
     dispatch_async(dispatch_get_main_queue()) { 
      // make sure to put on the main queue to update UI! 
     } 
    } 

    func session(session: WCSession, didReceiveMessageData messageData: NSData, replyHandler: (NSData) -> Void) { 
     // handle receiving message data 
     dispatch_async(dispatch_get_main_queue()) { 
      // make sure to put on the main queue to update UI! 
     } 
    } 
} 

Answer 1

Das Problem, das Sie stoßen, ist, dass Sie die gleiche Singleton verwenden, wenn sowohl das iOS SDK kompiliert und das watchOS SDK. Einige der Eigenschaften sind nur auf dem einen oder dem anderen verfügbar, so dass Ihr Code dies berücksichtigen muss. Insbesondere, wenn Sie für WCSession an der Objective-C-Header aussehen werden Sie sehen:

/** Check if iOS device is paired to a watch */ 
@property (nonatomic, readonly, getter=isPaired) BOOL paired __WATCHOS_UNAVAILABLE; 

/** Check if the user has the Watch app installed */ 
@property (nonatomic, readonly, getter=isWatchAppInstalled) BOOL watchAppInstalled __WATCHOS_UNAVAILABLE; 

Das bedeutet, wenn Sie die Singleton halten wollen, werden Sie diesen Abschnitt ändern müssen:

if let session = session where session.paired && session.watchAppInstalled { 
    return session 
} 
return nil 

etwas mehr wie zu sein (es gibt auch andere Möglichkeiten, dies zu lösen, aber das ist eine Lösung):

#if os(iOS) 
    if let session = session where session.paired && session.watchAppInstalled { 
     return session 
    } 
    return nil 
#else 
    return session 
#endif 

Dieser bedingt unterschiedlichen Code, ob sein Wesen der Kompilierung kompiliert d für iOS oder watchOS. Du musst diesen Trick vielleicht auch in anderen Teilen des Singletons anwenden, aber das sollte dir zumindest den Anfang machen!