Basic Implementation

Author: smuellner

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,28 @@
+// swift-tools-version:5.3
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "GameKitService.swift",
+    platforms: [ .iOS(SupportedPlatform.IOSVersion.v13),
+                 .macOS(SupportedPlatform.MacOSVersion.v10_15),
+                 .tvOS(SupportedPlatform.TVOSVersion.v13),
+                 .watchOS(SupportedPlatform.WatchOSVersion.v6)
+    ],
+    products: [
+        .library(
+            name: "GameKitService",
+            targets: ["GameKitService"]),
+    ],
+    dependencies: [
+    ],
+    targets: [
+        .target(
+            name: "GameKitService",
+            dependencies: []),
+        .testTarget(
+            name: "GameKitServiceTests",
+            dependencies: ["GameKitService"]),
+    ]
+)

Package.swift

@@ -1,2 +1,3 @@
 # GameKitService.swift
- 
+
+A description of this package.

README.md

@@ -0,0 +1,125 @@
+///
+/// GameKitService.swift
+///
+///
+/// Created by Sascha Müllner on 04.12.20.
+
+import Combine
+import Foundation
+import GameKit
+
+/// GameKitService
+public class GameKitService : NSObject, GKMatchDelegate, GKLocalPlayerListener, GameKitServiceProtocol {
+
+    fileprivate var players = [String : GKPlayer]()
+
+    public var authenticated = CurrentValueSubject<Bool, Never>(false)
+    public var started = PassthroughSubject<GKMatch, Never>()
+    public var received = PassthroughSubject<(match: GKMatch, data: Data, player: GKPlayer), Never>()
+    public var ended = PassthroughSubject<GKMatch, Never>()
+
+    public var match: GKMatch?
+
+    public static let shared = GameKitService()
+
+    private override init() {
+        super.init()
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(GameKitService.authenticationChanged),
+            name: Notification.Name.GKPlayerAuthenticationDidChangeNotificationName,
+            object: nil)
+    }
+
+    // MARK: Public functions
+
+    public func start(_ match: GKMatch) {
+        self.match = match
+        match.delegate = self
+    }
+
+    public func send(_ data: Data) throws {
+        guard let match = self.match else { return }
+        try match.sendData(toAllPlayers: data, with: .reliable)
+    }
+    
+    public func send(_ data: Data, players: [GKPlayer]) throws {
+        guard let match = self.match else { return }
+        try match.send(data, to: players, dataMode: .reliable)
+    }
+
+    // MARK: GKMatchDelegate
+
+    public func match(_ match: GKMatch, didReceive data: Data, fromRemotePlayer player: GKPlayer) {
+        if self.match != match {
+            return
+        }
+        self.received.send((match: match, data: data, player: player))
+    }
+
+    public func match(_ match: GKMatch, player: GKPlayer, didChange state: GKPlayerConnectionState) {
+        switch state {
+            case .connected:
+                self.lookupPlayers()
+                break
+            case .disconnected:
+                self.ended.send(match)
+                self.match = nil
+                break
+            default:
+                break
+        }
+    }
+
+    public func match(_ match: GKMatch, didFailWithError error: Error?) {
+        if self.match != match {
+            return
+        }
+
+        print("Match failed with error: \(String(describing: error?.localizedDescription))")
+        self.ended.send(match)
+    }
+
+
+    // MARK: GKLocalPlayerListener
+    public func player(_ player: GKPlayer, didAccept invite: GKInvite) {
+
+    }
+
+    // MARK: Private functions
+    @objc fileprivate func authenticationChanged() {
+        if GKLocalPlayer.local.isAuthenticated && !self.authenticated.value  {
+            self.authenticated.value = true
+        } else {
+            self.authenticated.value  = false
+        }
+    }
+
+    fileprivate func lookupPlayers() {
+        guard let match = self.match else { return }
+
+        let playerIDs = match.players.map { $0.teamPlayerID }
+
+        GKPlayer.loadPlayers(forIdentifiers: playerIDs) { (players, error) in
+            guard error == nil else {
+                print("Error retrieving player info: \(String(describing: error?.localizedDescription))")
+                self.ended.send(match)
+                return
+            }
+
+            guard let players = players else {
+                print("Error retrieving players; returned nil")
+                return
+            }
+
+            for player in players {
+                print("Found player: \(String(describing: player.alias))")
+                self.players[player.teamPlayerID] = player
+            }
+
+            GKMatchmaker.shared().finishMatchmaking(for: match)
+            self.started.send(match)
+        }
+    }
+}

Sources/GameKitService/GameKitService.swift

@@ -0,0 +1,30 @@
+///
+/// GameKitServiceProtocol.swift
+/// 
+/// 
+/// Created by Sascha Müllner on 04.12.20.
+
+import Combine
+import Foundation
+import GameKit
+
+/// Custom delegate used to provide information to the application implementing GameKitServiceProtocol.
+public protocol GameKitServiceProtocol {
+
+    var authenticated: CurrentValueSubject<Bool, Never> { get }
+
+    /// Method called when a match has been initiated.
+    var started: PassthroughSubject<GKMatch, Never> { get }
+
+    /// Method called when the device receives data about the match from another device in the match.
+    var received: PassthroughSubject<(match: GKMatch, data: Data, player: GKPlayer), Never> { get }
+
+    /// Method called when the match has ended.
+    var ended: PassthroughSubject<GKMatch, Never> { get }
+
+    func start(_ match: GKMatch)
+
+    func send(_ data: Data) throws
+
+    func send(_ data: Data, players: [GKPlayer]) throws
+}

Sources/GameKitService/GameKitServiceProtocol.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import GameKitService
+
+final class GameKitServiceTests: XCTestCase {
+    func testExample() {
+        // This is an example of a functional test case.
+        // Use XCTAssert and related functions to verify your tests produce the correct
+        // results.
+        // XCTAssertEqual(GameKitService().text, "Hello, World!")
+    }
+
+    static var allTests = [
+        ("testExample", testExample),
+    ]
+}

Tests/GameKitServiceTests/GameKitServiceTests.swift

@@ -0,0 +1,9 @@
+import XCTest
+
+#if !canImport(ObjectiveC)
+public func allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(GameKitService_swiftTests.allTests),
+    ]
+}
+#endif

Tests/GameKitServiceTests/XCTestManifests.swift

@@ -0,0 +1,7 @@
+import XCTest
+
+import GameKitService_swiftTests
+
+var tests = [XCTestCaseEntry]()
+tests += GameKitService_swiftTests.allTests()
+XCTMain(tests)