Updates: Apple Music controls are now working, some more segmenting and tidying of code and comments

Author: xan-m

Infini-iOS/BLEManager.swift

@@ -21,12 +21,22 @@ let batCBUUID = CBUUID(string: "2A19")
 let timeCBUUID = CBUUID(string: "2A2B")
 let notifyCBUUID = CBUUID(string: "2A46")
 let musicControlCBUUID = CBUUID(string: "00000001-78FC-48FE-8E23-433B3A1942D0")
+let musicTrackCBUUID = CBUUID(string: "00000004-78FC-48FE-8E23-433B3A1942D0")
+let musicArtistCBUUID = CBUUID(string: "00000003-78FC-48FE-8E23-433B3A1942D0")
 
 class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate {
 
 	var myCentral: CBCentralManager!
 	var notifyCharacteristic: CBCharacteristic!
 
+	struct musicCharacteristics {
+		var control: CBCharacteristic!
+		var track: CBCharacteristic!
+		var artist: CBCharacteristic!
+	}
+	
+	@Published var musicChars = musicCharacteristics()
+	
 	// UI flag variables
 	@Published var isSwitchedOn = false									// for now this is used to display if bluetooth is on in the main app screen. maybe an alert in the future?
 	@Published var isScanning = false									// another UI flag. Probably not necessary for anything but debugging. I dunno maybe a little swirly animation or something could be triggered by this
@@ -86,7 +96,7 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate {
 
 	func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
 
-		var peripheralName: String! // ** not necessary without below scan list thing
+		var peripheralName: String!
 
 		if let name = advertisementData[CBAdvertisementDataLocalNameKey] as? String {
 			peripheralName = name
@@ -98,23 +108,18 @@ class BLEManager: NSObject, ObservableObject, CBCentralManagerDelegate {
 		let newPeripheral = Peripheral(id: peripheralDictionary.count, name: peripheralName, rssi: RSSI.intValue, peripheralHash: peripheral.hash)
 
 		// compare peripheral hashes to make sure we're only adding each device once -- super helpful if you have a very noisy BLE advertiser nearby!
+		// this hash value is functional only for separating devices during this search, and is not at all guaranteed to be a persistent value. Probably not to be trusted for long-term autoconnect persistence. So far, I have gotten the same value for my PineTime every time I run the app, but based on the Apple docs this is not a guarantee.
 		if !peripherals.contains(where: {$0.peripheralHash == newPeripheral.peripheralHash}) {
 			// I think there's probably a way to get rid of this array someday, but for now it's useful for displaying the device names. You cant have a Peripheral struct as a key in the peripheralDictionary, so there has to be some way to pass the names to the UI, and the peripherals array seems like it.
 			peripherals.append(newPeripheral)
 			peripheralDictionary[newPeripheral.peripheralHash] = peripheral
 
 			print(newPeripheral, "added to list")
-			/*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*
-			TODO: hey alpha testers! Please send me a message/comment/email/toot/whatever with the peripheralHash of your PineTime! While the hash is valuable for weeding out repeat broadcasters, I'm not sure what exactly is hashed, and if that would be unique between two of the same device. If it's just a hash of "InfiniTime" + $INFINITIMEUUID, then there will be unintended collisions and this won't solve anything for people that have more than one InfiniTime watch to sync.
-			
-			I'm getting the same value each time I run the app (138271609), let's hope yours is different!
-			*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*/
 		}
 	}
 
 	func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
 		self.infiniTime.discoverServices(nil)
-		sendNotification(notification: "iOS Connected!")
 	}
 
 	func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
@@ -148,15 +153,30 @@ extension BLEManager: CBPeripheralDelegate {
 				peripheral.readValue(for: characteristic)
 			}
 
-			// subscribe to values that can be subscribed to
+			// subscribe to all values that can be subscribed to.
+			// TODO: separate this out and subscribe individually for each service in a separate .swift document so this isn't so monolithic
 			if characteristic.properties.contains(.notify) {
+				switch characteristic.uuid {
+				case musicControlCBUUID:
+					peripheral.setNotifyValue(true, for: characteristic)
+					print("subscribed to", characteristic.uuid)
+				case hrmCBUUID:
+					peripheral.setNotifyValue(true, for: characteristic)
+					print("subscribed to", characteristic.uuid)
+				case batCBUUID:
+					peripheral.setNotifyValue(true, for: characteristic)
+					print("subscribed to", characteristic.uuid)
+				default:
+					break
+				}
 				peripheral.setNotifyValue(true, for: characteristic)
 			}
 
 			if characteristic.properties.contains(.write) {
 				if characteristic.uuid == notifyCBUUID {
-					// I'm sure there's a less clunky way to grab the full characteristic for the sendNotification() function, but this ad-hoc method works okay and allows it to be published as well.
+					// I'm sure there's a less clunky way to grab the full characteristic for the sendNotification() function, but this works fine for now
 					notifyCharacteristic = characteristic
+					sendNotification(notification: "iOS Connected!")
 				}
 			}
 		}
@@ -165,11 +185,18 @@ extension BLEManager: CBPeripheralDelegate {
 		switch characteristic.uuid {
 		case musicControlCBUUID:
 			// listen for the music controller notifications
+			musicChars.control = characteristic
 			let musicControl = [UInt8](characteristic.value!)
-			let musicNumber = String(musicControl[0])
-			// for now just print to console, but I am getting the numbers as a string here, so hopefully I can use that to control music apps soon
-			print(musicNumber) // debug
-		
+			controlMusic(controlNumber: Int(musicControl[0]))
+			
+		case musicTrackCBUUID:
+			// select track characteristic for writing to music app
+			musicChars.track = characteristic
+			
+		case musicArtistCBUUID:
+			// select artist characteristic for writing to music app
+			musicChars.artist = characteristic
+			
 		case hrmCBUUID:
 			// read heart rate hex, convert to decimal
 			let bpm = heartRate(from: characteristic)
@@ -188,18 +215,14 @@ extension BLEManager: CBPeripheralDelegate {
 			break
 		}
 	}
-
-	func sendNotification(notification: String) {
-		// I'm pretty sure this is due to a lack of understanding on my part of the notification protocol, but sending ascii text as a notification eats the first 3 characters seemingly no matter what they are, so add 3 spaces here to absorb that, then encode the string to ASCII Data
-		let paddedNotification = "   " + notification
-		let notificationData = paddedNotification.data(using: .ascii)!
-		
-		// this line prevents crashes when sending a notification before the app has finished establishing the notification write characteristic
-		if notifyCharacteristic != nil {
-			infiniTime.writeValue(notificationData, for: notifyCharacteristic, type: .withResponse)
-		}
+	
+	// this function converts string to ascii and writes to the selected characteristic. Used for notifications and music app
+	func writeASCIIToPineTime(message: String, characteristic: CBCharacteristic) {
+		let writeData = message.data(using: .ascii)!
+		infiniTime.writeValue(writeData, for: characteristic, type: .withResponse)
 	}
 
+	
 	// function to translate heart rate to decimal, copied straight up from this tut: https://www.raywenderlich.com/231-core-bluetooth-tutorial-for-ios-heart-rate-monitor#toc-anchor-014
 	private func heartRate(from characteristic: CBCharacteristic) -> Int {
 		guard let characteristicData = characteristic.value else { return -1 }

Infini-iOS/Info.plist

@@ -22,6 +22,10 @@
 	<true/>
 	<key>NSBluetoothAlwaysUsageDescription</key>
 	<string>This app uses bluetooth to communicate with your PineTime.</string>
+	<key>kTCCServiceMediaLibrary</key>
+	<string>This app needs permission to allow your PineTime to control your music.</string>
+	<key>NSAppleMusicUsageDescription</key>
+	<string>This app needs permission to allow your PineTime to control your music.</string>
 	<key>UIApplicationSceneManifest</key>
 	<dict>
 		<key>UIApplicationSupportsMultipleScenes</key>

Infini-iOS/Music/BLEMusic.swift

@@ -0,0 +1,43 @@
+//
+//  BLEMusic.swift
+//  Infini-iOS
+//
+//  Created by Alex Emry on 8/7/21.
+//
+
+import Foundation
+
+extension BLEManager{
+	func controlMusic(controlNumber: Int) {
+
+		let musicController = MusicController()
+		
+		// when CoreBluetooth gets an update from the music control characteristic, parse that number and take an action, and in any case, make sure the track and artist are relatively up to date
+		switch controlNumber {
+		case 0:
+			if musicController.getPlaybackStatus() == 1 {
+				musicController.pause()
+			} else {
+				musicController.play()
+			}
+		case 2:
+			print("volUp") // system volume controls are not accessible from an app
+		case 3:
+			musicController.nextTrack()
+		case 4:
+			musicController.prevTrack()
+		case 5:
+			print("volDown") // system volume controls are not accessible from an app
+		default:
+			break
+		}
+		updateMusicInformation(songInfo: musicController.getCurrentSongInfo())
+	}
+	func updateMusicInformation(songInfo: MusicController.songInfo) {
+		let musicController = MusicController()
+		let songInfo = musicController.getCurrentSongInfo()
+		
+		writeASCIIToPineTime(message: songInfo.trackName, characteristic: musicChars.track)
+		writeASCIIToPineTime(message: songInfo.artistName, characteristic: musicChars.artist)
+	}
+}

Infini-iOS/Music/MusicController.swift

@@ -0,0 +1,59 @@
+//
+//  MusicController.swift
+//  Infini-iOS
+//
+//  Created by Alex Emry on 8/7/21.
+//
+
+import Foundation
+import MediaPlayer
+
+class MusicController: NSObject, ObservableObject{
+	/*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*
+	For now, this is a rudimentary implementation of apple's MediaPlayer framework, which unfortunately only works with Apple Music. Apple does not allow control of system volume levels at from the app level, so the volume controls do not work currently. Control of the "Now Playing" media on the device is also not supported at the app level, so we have to specifically work with Apple Music through the existing framework.
+	
+	In the future, if Apple's proprietary AMS (Apple Media Service) is implemented in InfiniTime, these controls should work on their own, and the track/artist/elapsed time/total time should automatically populate. Not sure how much work that would be to implement, so this may be the best we can do for a while.
+	
+	TODO: figure out the formatting that PineTime expects for time elapsed/total time. Hex value of 0101 = 12:32, 0102 = 04:48. Writing decimal does nothing. ASCII also gives wacky results
+	*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*/
+	
+	var musicPlayer = MPMusicPlayerController.systemMusicPlayer
+	
+	let volumeView = MPVolumeView()
+	
+	struct songInfo {
+		var trackName: String!
+		var artistName: String!
+		//var currentDuration: Int
+	}
+	
+	override init() {
+		super.init()
+	}
+	
+	func getPlaybackStatus() -> Int {
+		musicPlayer.playbackState.rawValue
+	}
+	
+	func pause() {
+		musicPlayer.pause()
+	}
+	
+	func play() {
+		musicPlayer.play()
+	}
+	
+	func nextTrack() {
+		musicPlayer.skipToNextItem()
+	}
+	
+	func prevTrack() {
+		musicPlayer.skipToPreviousItem()
+	}
+	
+	func getCurrentSongInfo() -> songInfo {
+		let currentTrack = musicPlayer.nowPlayingItem
+		let currentSongInfo = songInfo(trackName: currentTrack?.title ?? "Not Playing", artistName: currentTrack?.artist ?? "Not Playing")
+		return currentSongInfo
+	}
+}

Infini-iOS/Notifications/Notifications.swift

@@ -0,0 +1,16 @@
+//
+//  Notifications.swift
+//  Infini-iOS
+//
+//  Created by Alex Emry on 8/8/21.
+//
+
+import Foundation
+
+extension BLEManager {
+	func sendNotification(notification: String) {
+		// I'm pretty sure this is due to a lack of understanding on my part of the notification protocol, but sending ascii text as a notification eats the first 3 characters seemingly no matter what they are, so add 3 spaces here to absorb that, then encode the string to ASCII Data
+		let paddedNotification = ("123" + notification) //.data(using: .ascii)!
+		writeASCIIToPineTime(message: paddedNotification, characteristic: notifyCharacteristic)
+	}
+}

README.md

@@ -3,41 +3,35 @@
 This is a proof-of-concept, barely-functional iOS application to interact with your PineTime running (at least) InfiniTime 1.3.0 (and maybe more, I haven't tested it against other watches or OSes).
 
 ### What works:
-- Scan nearby devices and allow the user to select a device to connect to 
-  - so far this is card coded to be a device named 'InfiniTime' because I don't have anything else to test it against and I don't want to fat-finger the wrong device and have it break
+- Scan nearby devices and allow the user to select an InfiniTime device to connect to
 - Connect to a PineTime running InfiniTime 1.3.0
 - Set time and date immediately after connection
 - Read heart rate, and subscribe to HRM's notifier for updated values
 - Read battery level, and subscribe to battery level's notifier for updated values
 - Display heart rate, battery level, and connection/bluetooth/scanning status to app main page
+- Music controls on InfiniTime can control Apple Music. I can't access system-level music controls or system volume from within an app, so the controls literally only work on Apple Music.
 
 ### What sort of works but mostly just sucks:
 - The UI: It's just a proof of concept so far, so I put as little effort as possible into the UI.
-- Notifications: I can send a test notification to the PineTime, but can't send phone notifications to the watch yet.
-- Music controls: I have subscribed to the InfiniTime music app notifier, but so far have only implemented printing music control button presses to console. They do print though, so it should be doable if I can access the phone's music controls somehow!
+- Notifications: I can send a test notification to the PineTime, but can't send phone notifications to the watch yet. Apple requires the ANCS protocol and bonding to be implemented on the peripheral device, so there's some big hills to climb before notifications are functional.
 
 ### What's next:
-- Figure out how to send phone notifications to watch
-- Figure out how to control music from watch
-- Optional auto-connect: save some device-specific characteristic (MAC address? Serial number?) to the app, and allow users to automatically connect to their device. I know I probably won't want to connect to anything other than my own pinetime with very few exceptions, so it'd save me a few taps if it just snagged my watch automatically when I open the app.
-- Learn anything whatsoever about making an app design in SwiftUI that isn't a horrific clusterwhoops 
-- Send notifications to the phone, probably. Might be nice to get a buzz on your phone if the watch disconnects for some reason
-- User-configurable settings:
-  - select device for autoconnect
-  - enable/disable notifications
-  - taking suggestions
-- Clean everything up. Still tons of commented lines and code blocks from debugging and trial and error stuff that I should really remove. Probably should add a few more explanatory comments here and there too, mostly for my own benefit...
-- I mean, there's the navigation thing? I guess poke at that. I'm not super sure that's a priority for me at all, but if that's something that people want I can definitely look into it sooner.
+- Learn anything whatsoever about making an app design in SwiftUI that isn't an awful mess 
+- Send notifications to the phone, probably. Might be nice to get a buzz on your phone if the watch disconnects for some reason or if the watch battery is running low
+- User-configurable settings, like enabling or disabling Apple Music controls, notifications, etc
+- Clean everything up. Being my first major foray into larger-scale coding projects, I have not done a great job of compartmentalizing my code, so the BLEManager.swift file is pretty monolithic. 
+- Watch navigation app. This is a lower priority to me personally, but I'll definitely give it a shot eventually. Based on how the music control and notifications have gone, I'm guessing there's another proprietary Apple service that will need to be implemented to make this work.
 
-### How to try it out
+### How to try it out:
 - Snag this repo and open it in XCode on a Mac
 - Plug an iPhone into your computer and select it as the build target in XCode
 - Make sure you're signed into your appleID in XCode and that you've done whatever it wants you to do to flag yourself as a code signer
 - Change the code signing information in the Infini-iOS properties:
   - Click the main project in the files sidebar
   - Navigate to the 'Signing and Capabilities' tab
   - Change the 'Team' pulldown to reflect your appleID that you used to sign into XCode
+  - Change the Bundle Identifier to match your team
 - Build and run!
 
-### Disclaimers
-**This is the first time I've worked with Swift, SwiftUI, XCode, BLE, or anything else in this application. I take no responsibility for what happens if you interact with this repository in any way. If it breaks your phone or your watch or your brain,** ***that's on you buddy!***
+### Disclaimer
+**This is the first time I've worked with Swift, SwiftUI, XCode, BLE, or anything else in this application. I take no responsibility for what happens if you interact with this repository in any way. If it breaks your phone, your watch, or your brain,** ***that's on you buddy!***