139 lines
3.9 KiB
Swift
139 lines
3.9 KiB
Swift
import Vapor
|
|
import SwiftyGPIO
|
|
import APNSwift
|
|
import NIO
|
|
import Crypto
|
|
|
|
private struct Payload: Codable {}
|
|
|
|
private var apnsConfiguration: APNSClientConfiguration!
|
|
private var apnsNotification: APNSAlertNotification<Payload>!
|
|
private let apnsEventGroup = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
|
|
private let apnsRequestEncoder = JSONEncoder()
|
|
private let apnsResponseDecoder = JSONDecoder()
|
|
|
|
// configures your application
|
|
public func configure(_ app: Application) throws {
|
|
|
|
let resourcesFolderUrl = URL(fileURLWithPath: app.directory.resourcesDirectory)
|
|
let configUrl = resourcesFolderUrl.appendingPathComponent("config.json")
|
|
|
|
let config: ServerConfiguration
|
|
do {
|
|
let data = try Data(contentsOf: configUrl)
|
|
config = try JSONDecoder().decode(from: data)
|
|
} catch {
|
|
print("Failed to load config from \(configUrl.path): \(error)")
|
|
return
|
|
}
|
|
|
|
app.http.server.configuration.port = config.port
|
|
|
|
guard configureAPNS(config) else {
|
|
serverStatus = .failedToStart
|
|
return
|
|
}
|
|
|
|
configureGPIO(config)
|
|
|
|
// register routes
|
|
try routes(app)
|
|
|
|
serverStatus = .running
|
|
}
|
|
|
|
private extension JSONDecoder {
|
|
|
|
func decode<T>(from data: Data) throws -> T where T: Decodable {
|
|
try self.decode(T.self, from: data)
|
|
}
|
|
}
|
|
|
|
private func load(keyAtPath path: String) -> P256.Signing.PrivateKey? {
|
|
do {
|
|
guard let key = try P256.Signing.PrivateKey.loadFrom(filePath: path) else {
|
|
print("Failed to read key \(path)")
|
|
return nil
|
|
}
|
|
return key
|
|
} catch {
|
|
print("Failed to load key \(error)")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
private func configureAPNS(_ config: ServerConfiguration) -> Bool {
|
|
guard let key = load(keyAtPath: config.privateKeyFilePath) else {
|
|
return false
|
|
}
|
|
let authentication = APNSClientConfiguration.AuthenticationMethod.jwt(
|
|
privateKey: key,
|
|
keyIdentifier: config.keyIdentifier,
|
|
teamIdentifier: config.teamIdentifier)
|
|
|
|
|
|
apnsConfiguration = APNSClientConfiguration(
|
|
authenticationMethod: authentication,
|
|
environment: .sandbox)
|
|
|
|
let alert = APNSAlertNotificationContent(
|
|
title: .raw(config.messageTitle),
|
|
body: .raw(config.messageBody))
|
|
|
|
apnsNotification = APNSAlertNotification(
|
|
alert: alert,
|
|
expiration: .none,
|
|
priority: .immediately,
|
|
topic: config.topic,
|
|
payload: Payload(),
|
|
sound: .default)
|
|
return true
|
|
}
|
|
|
|
private func configureGPIO(_ config: ServerConfiguration) {
|
|
let gpio = RaspberryGPIO(
|
|
name: "GPIO\(config.buttonPin)",
|
|
id: config.buttonPin,
|
|
baseAddr: 0x7E000000)
|
|
|
|
gpio.direction = .IN
|
|
gpio.pull = .down
|
|
gpio.bounceTime = config.bounceTime
|
|
gpio.onChange { _ in
|
|
log(info: "Push detected")
|
|
sendPush()
|
|
}
|
|
log(info: "GPIO \(config.buttonPin) configured")
|
|
}
|
|
|
|
private func sendPush() {
|
|
Task(priority: .userInitiated) {
|
|
let client = APNSClient(
|
|
configuration: apnsConfiguration,
|
|
eventLoopGroupProvider: .shared(apnsEventGroup),
|
|
responseDecoder: apnsResponseDecoder,
|
|
requestEncoder: apnsRequestEncoder)
|
|
log(info: "Client created")
|
|
do {
|
|
for token in knownTokens {
|
|
log(info: "Sending push to \(token.prefix(6))...")
|
|
try await client.sendAlertNotification(
|
|
apnsNotification,
|
|
deviceToken: token,
|
|
deadline: .now() + .seconds(10))
|
|
log(info: "Sent push to \(token.prefix(6))...")
|
|
}
|
|
} catch let error as APNSError {
|
|
print(error)
|
|
} catch {
|
|
log(error: error.localizedDescription)
|
|
}
|
|
do {
|
|
log("Closing client")
|
|
try client.syncShutdown()
|
|
} catch {
|
|
log(error: error.localizedDescription)
|
|
}
|
|
}
|
|
}
|