在我的项目中，我使用 Watch Connectivity 在 Watch 和 iPhone 之间发送消息。我可以在启动应用程序时向手机发送消息并接收字符串数组，但是在使用操作时出现以下错误；

Error Domain=WCErrorDomain Code=7012 "Message reply took too long."

这是设置的方式；

首先， watch 向手机发送一条消息，然后手机发送一个字符串数组以显示在 WKInterfaceTable 中。这有时在加载应用程序时有效。 (我获取所有名为 Items 的 NSManagedObjects 并使用它们的 title 字符串属性存储在名为 watchItems 的 array 中。

但是，我在 watch 上有一个操作，删除数组中的所有项目并用新数据刷新表。

watch 上的 Action 使用sendMessage 函数将item 发送到手机以从数组中删除，然后手机将新更新的数组发送到 watch watch 会更新表格。但是，我要么返回相同的数组，要么返回错误。

非常简单，所以在 Swift 3 和 Watch OS3/iOS 10 之前一切都正常；整个应用程序曾经工作。

这是我设置所有内容的方式；

手机应用程序代理

import WatchConnectivity

class AppDelegate: UIResponder, UIApplicationDelegate, WCSessionDelegate {

var session : WCSession!

var items = [Items]()

func loadData() {
    let moc = (UIApplication.shared.delegate as! AppDelegate).managedObjectContext
    let request = NSFetchRequest<Items>(entityName: "Items")

    request.sortDescriptors = [NSSortDescriptor(key: "date", ascending: true)]
    request.predicate = NSPredicate(format: "remove == 0", "remove")

    do {
        try
            self.items = moc!.fetch(request)
        // success ...
    } catch {
        // failure
        print("Fetch failed")
    }
}

//WATCH EXTENSION FUNCTIONS
//IOS 9.3 
/** Called when the session has completed activation. If session state is WCSessionActivationStateNotActivated there will be an error with more details. */


//HAVE TO INCLUDE
@available(iOS 9.3, *)
func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: Error?){
   print("iPhone WCSession activation did complete")
}


@available(iOS 9.3, *)
func sessionDidDeactivate(_ session: WCSession) {}

func sessionWatchStateDidChange(_ session: WCSession) {}

func sessionDidBecomeInactive(_ session: WCSession) {

}

//APP DELEGATE FUNCTIONS

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey : Any]? = nil) -> Bool {

    //Check if session is supported and Activate
    if (WCSession.isSupported()) {
        session = WCSession.default()
        session.delegate = self;
        session.activate()
    }
    return true
}


}

//DID RECIEVE MESSAGE
func session(_ session: WCSession, didReceiveMessage message: [String : Any], replyHandler: @escaping ([String : Any]) -> Swift.Void) {


    loadData()

    func loadItems() {
        watchItems.removeAll()

        for a in self.items {
            watchItems.append(a.title)
        }
    }

    var watchItems = ["1","2","3","4","5"]

    let value = message["Value"] as? String

    //This is called when user loads app, and takes some time when using refresh action, sometimes times out 

    if value == "HELLOiPhone/+@=" {

        print("Hello Message Recieved")

        loadItems() 

        //send a reply
        replyHandler( [ "Items" : Items ] )

    }

    //Not sure if receiving but does not delete array and send back to watch
    if value == "removeALL@+=-/" {                        
        for index in self.items {
            index.remove = 1
            //Saves MOC
        }

        loadData()
        loadTasksData()

        //send a reply
        replyHandler( [ "Items" : Items ] )

    }
    else {
        for index in self.items {
            if index.title == value {
            index.remove = 1
            //Saves MOC
            }
        }

        loadData()
        loadTasksData()

        //send a reply
        replyHandler( [ "Items" : Items ] )
    }
}

观看

import WatchConnectivity

class SimplelistInterfaceController: WKInterfaceController, WCSessionDelegate  {


/** Called when the session has completed activation. If session state is WCSessionActivationStateNotActivated there will be an error with more details. */
@available(watchOS 2.2, *)
public func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: Error?) {

   //Fetch data is a function which sends a "HELLOiPhone/+@=" message to receive the array and displays in the table. This works 
   fetchData()
}


var session : WCSession!
var items = ["Refresh Items"]

override func didAppear() {
    fetchData()
}

override func willActivate() {
    // This method is called when watch view controller is about to be visible to user
    super.willActivate()
    //Check if session is supported and Activate
    if (WCSession.isSupported()) {
        session = WCSession.default()
        session.delegate = self
        session.activate()
    }
    fetchData()
}

override func awake(withContext context: Any?) {
    super.awake(withContext: context)
    fetchData()
}

@IBAction func refresh() {
    print("Refresh")
    //Works but sometimes message is delayed
    fetchData()
}

@IBAction func removeAll() {
    print("Remove All Items is called")
    if WCSession.default().isReachable {
        let messageToSend = ["Value":"removeALL@+=-/"]
        print("\(messageToSend)")
        session.sendMessage(messageToSend, replyHandler: { replyMessage in
            if let value = replyMessage["Items"] {
                self.items = value as! [String]

                Not receiving message
                print("Did Recieve Message, items = \(self.items)")
            }

            }, errorHandler: {error in
                // catch any errors here
                print(error)
        })
    }
    fetchData()
}

}

最佳答案

1. 您不应从一个目标 (iOS) 向第二个目标 (watchOS) 发送或接收自定义类对象，而应发送/接收字典格式的数据，例如 [String: Any] 并且此字典应包含数组您的自定义对象需要简单字典中键值对中的属性。这可以在 watch 端轻松解码。

2. 您应该创建一个扩展 WCSessionDelegate 的解耦类，如下所示，这样该类不仅可以在 ExtensionDelegate 中使用，而且可以在任何 WKInterfaceController 中使用。

   class WatchSessionManager: NSObject, WCSessionDelegate {
   
       static let sharedManager = WatchSessionManager()
   
       private override init() {
           super.init()
           self.startSession()
       }
   
       private let session: WCSession = WCSession.default
   
       func startSession() {
           session.delegate = self
           session.activate()
       }
   
       func tryWatchSendMessage(message: [String: Any], completion: (([String: Any]) -> Void)? = nil) {
           print("tryWatch \(message)")
           weak var weakSelf = self
           if #available(iOS 9.3, *) {
               if weakSelf?.session.activationState == .activated {
                   if weakSelf?.session.isReachable == true {
                       weakSelf?.session.sendMessage(message,
                                                     replyHandler: { [weak self]  ( response )  in
                                                       guard let slf = self else {return}
                                                       //Get the objects from response dictionary
                                                       completion?(response)
                           },
                                                     errorHandler: { [weak self] ( error )  in
                                                       guard let slf = self else {return}
                                                       print ( "Error sending message: % @ " ,  error )
                                                       // If the message failed to send, queue it up for future transfer
                                                       slf.session.transferUserInfo(message)
                       })
                   } else {
                       self.session.transferUserInfo(message)
                   }
               }else{
                   self.session.activate()
                   self.session.transferUserInfo(message)
               }
           } else {
               // Fallback on earlier versions
               if self.session.activationState == .activated {
                   if self.session.isReachable == true {
                       self.session.sendMessage(message,
                                                replyHandler: {  ( response )  in
                                                   //Get the objects from response dictionary
                                                   completion?(response)
                       },
                                                errorHandler: {  ( error )  in
                                                   print ( "Error sending message: % @ " ,  error )
                                                   // If the message failed to send, queue it up for future transfer
                                                   self.session.transferUserInfo(message)
                       })
                   } else {
                       self.session.transferUserInfo(message)
                   }
               }else{
                   self.session.activate()
                   self.session.transferUserInfo(message)
               }
           }
       }
   
   
   }
   

现在您可以轻松地向您的 iOS 应用程序发送消息以唤醒并从那里获取数据(例如从 CoreData)，在任何 WKInterfaceController 中使用上述函数，完成 block 将包含您所需的数据，例如

let dict: [String: Any] = ["request": "FirstLoad"]
WatchSessionManager.sharedManager.tryWatchSendMessage(message: dict,completion:{ (data) in print(data)})

您应该在 iOS 端使用此 WatchSessionManager 并接收请求，根据请求的键，您应该从核心存储/数据库中获取数据，并在 didreceiveMessage 函数的 replyHandler 中以简单的键值字典模式发送自定义对象列表如下所示。

 func session(_ session: WCSession, didReceiveMessage message: [String: Any], replyHandler: @escaping ([String: Any]) -> Void) {
 var dict: [String: Any] = [String: Any]()
 replyHandler(dict) //This dict will contain your resultant array to be sent to watchApp.
}

有时 iOS 应用程序(已终止状态)无法访问 WatchApp，为解决该问题，您应该在约 3 秒间隔的计时器内调用“tryWatchSendMessage”。当您从 watchApp 获得连接时，您应该使计时器无效。

WatchConnectivity 的 sendMessage 功能非常强大，可以唤醒您的应用程序。您应该以优化的方式使用它。

关于ios - "Message reply took too long."- Watch OS 3 的 watch 连接问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39515619/