Feat/rename overhead

.github/workflows/build.yml

@@ -0,0 +1,21 @@
+name: macOS
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Test
+        run: make test
+      - name: Build (release, universal)
+        run: make release
+      - uses: actions/upload-artifact@v4
+        with:
+          name: Overhead-macOS
+          path: build/Overhead.zip

.github/workflows/release.yml

@@ -0,0 +1,132 @@
+name: Release
+
+# Publishing a release (on GitHub: Releases › Draft a new release › new tag like 1.2.0 or v1.2.0 › Publish, or
+# `git tag v1.2.0 && git push origin v1.2.0`) creates a version tag, which runs this workflow. The app gets its
+# version from the tag, is tested and built for Apple Silicon and Intel, and Overhead.zip is attached to the
+# release with its SHA-256, along with SonyNotch.zip: the same app for the updater of SonyNotch 1.4 and older (see
+# the Makefile). The Homebrew cask in flotttt/homebrew-tap is then pointed at it (needs the HOMEBREW_TAP_TOKEN
+# secret, skipped without it).
+#
+# To build a release whose tag didn't run the workflow: Actions › Release › Run workflow, with that tag.
+#
+# The app is signed with the "SonyNotch Code Signing" certificate (SIGNING_CERT_P12 and SIGNING_CERT_PASSWORD
+# secrets), the same for every release, so macOS keeps its Bluetooth and music app permissions across updates. It
+# keeps the app's former name: a new certificate would cost users those permissions.
+
+on:
+  push:
+    tags: ["v[0-9]+.[0-9]+.[0-9]+", "[0-9]+.[0-9]+.[0-9]+"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag of the release to build (e.g. 1.2.0 or v1.2.0)"
+        required: true
+
+permissions:
+  contents: write
+
+env:
+  TAG: ${{ inputs.tag || github.ref_name }}
+
+jobs:
+  release:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ env.TAG }}
+
+      - name: Set the app version from the tag
+        run: |
+          VERSION="${TAG#v}"
+          if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "The tag $TAG isn't a version like 1.2.0 or v1.2.0."
+            exit 1
+          fi
+          echo "VERSION=$VERSION" >> "$GITHUB_ENV"
+          /usr/libexec/PlistBuddy -c "Set :CFBundleShortVersionString $VERSION" Client/macos/info.plist
+          /usr/libexec/PlistBuddy -c "Set :CFBundleVersion ${{ github.run_number }}" Client/macos/info.plist
+
+      - name: Test
+        run: make test
+
+      - name: Import the signing certificate
+        env:
+          SIGNING_CERT_P12: ${{ secrets.SIGNING_CERT_P12 }}
+          SIGNING_CERT_PASSWORD: ${{ secrets.SIGNING_CERT_PASSWORD }}
+        run: |
+          if [ -z "$SIGNING_CERT_P12" ]; then
+            echo "The SIGNING_CERT_P12 secret is missing: a release signed otherwise would lose users' permissions."
+            exit 1
+          fi
+          KEYCHAIN="$RUNNER_TEMP/signing.keychain-db"
+          KEYCHAIN_PASSWORD=$(openssl rand -hex 16)
+          security create-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN"
+          security set-keychain-settings -lut 3600 "$KEYCHAIN"
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" "$KEYCHAIN"
+          echo "$SIGNING_CERT_P12" | base64 -D > "$RUNNER_TEMP/signing.p12"
+          security import "$RUNNER_TEMP/signing.p12" -k "$KEYCHAIN" -P "$SIGNING_CERT_PASSWORD" -T /usr/bin/codesign
+          security set-key-partition-list -S apple-tool:,apple: -s -k "$KEYCHAIN_PASSWORD" "$KEYCHAIN" > /dev/null
+          rm "$RUNNER_TEMP/signing.p12"
+          # codesign only looks for identities in the keychain search list, whatever --keychain says.
+          security list-keychains -d user -s "$KEYCHAIN" $(security list-keychains -d user | tr -d '"')
+          security find-identity -p codesigning "$KEYCHAIN"
+          # The certificate's SHA-1 names it without a lookup by common name.
+          HASH=$(security find-certificate -c "SonyNotch Code Signing" -Z "$KEYCHAIN" | awk '/SHA-1 hash:/ { print $NF }')
+          if [ -z "$HASH" ]; then
+            echo "The signing certificate isn't in the keychain."
+            exit 1
+          fi
+          echo "SIGN_KEYCHAIN=$KEYCHAIN" >> "$GITHUB_ENV"
+          echo "SIGN_IDENTITY=$HASH" >> "$GITHUB_ENV"
+
+      - name: Build (release, universal)
+        run: make release
+
+      - name: Check the signature
+        run: codesign -dr - build/Overhead.app 2>&1 | grep -q 'certificate root'
+
+      - name: Checksum
+        run: |
+          cd build
+          shasum -a 256 Overhead.zip | tee Overhead.zip.sha256
+          shasum -a 256 SonyNotch.zip | tee SonyNotch.zip.sha256
+
+      # A release already made on GitHub for this tag (title and notes written there) only gets the files.
+      - name: Publish the release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          FILES="build/Overhead.zip build/Overhead.zip.sha256 build/SonyNotch.zip build/SonyNotch.zip.sha256"
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            gh release upload "$TAG" $FILES --clobber
+          else
+            gh release create "$TAG" $FILES \
+              --title "Overhead $VERSION" \
+              --generate-notes
+          fi
+
+      # The download URL uses the exact tag, since tags may or may not start with "v".
+      - name: Update the Homebrew cask
+        env:
+          GH_TOKEN: ${{ secrets.HOMEBREW_TAP_TOKEN }}
+        run: |
+          if [ -z "$GH_TOKEN" ]; then
+            echo "HOMEBREW_TAP_TOKEN isn't set, the Homebrew cask isn't updated."
+            exit 0
+          fi
+          FILE=Casks/overhead.rb
+          SHA256=$(cut -d ' ' -f 1 build/Overhead.zip.sha256)
+          URL="https://github.com/flotttt/Overhead/releases/download/$TAG/Overhead.zip"
+          gh api "repos/flotttt/homebrew-tap/contents/$FILE" > current.json
+          jq -r .content current.json | base64 -D > overhead.rb
+          sed -i '' -E \
+            -e "s|^  version \".*\"|  version \"$VERSION\"|" \
+            -e "s|^  sha256 \".*\"|  sha256 \"$SHA256\"|" \
+            -e "s|^  url \".*\"|  url \"$URL\"|" \
+            overhead.rb
+          gh api -X PUT "repos/flotttt/homebrew-tap/contents/$FILE" \
+            -f message="overhead $VERSION" \
+            -f content="$(base64 -i overhead.rb)" \
+            -f sha="$(jq -r .sha current.json)" > /dev/null
+          echo "Homebrew cask updated to $VERSION"

.gitignore

@@ -523,10 +523,9 @@ MigrationBackup/
 .ionide/
 
 # End of https://www.toptal.com/developers/gitignore/api/c++,visualstudio,python
-Client/imgui.ini
 
 # vscode
 .vscode/
 
-# linux build
-Client/linux/sonyheadphonesclient.build/
+# local working notes
+.superpowers/

Client/BluetoothWrapper.cpp

@@ -27,7 +27,9 @@ BluetoothWrapper& BluetoothWrapper::operator=(BluetoothWrapper&& other) noexcept
 int BluetoothWrapper::sendCommand(const std::vector<char>& bytes)
 {
 	std::lock_guard guard(this->_connectorMtx);
-	auto data = CommandSerializer::packageDataForBt(bytes, DATA_TYPE::DATA_MDR, this->_seqNumber++);
+	// Use the current seq, don't advance it here: the next seq comes from the device's ACK
+	// (_waitForAck), so if this frame goes unanswered its seq is simply reused on the next call.
+	auto data = CommandSerializer::packageDataForBt(bytes, DATA_TYPE::DATA_MDR, this->_seqNumber);
 	auto bytesSent = this->_connector->send(data.data(), data.size());
 
 	this->_waitForAck();
@@ -68,7 +70,9 @@ SonyProtocolVersion BluetoothWrapper::getProtocolVersion() noexcept
 Buffer BluetoothWrapper::sendCommandAndReadResponse(const std::vector<char>& bytes, unsigned char retCommandId, int retSubType)
 {
 	std::lock_guard guard(this->_connectorMtx);
-	auto data = CommandSerializer::packageDataForBt(bytes, DATA_TYPE::DATA_MDR, this->_seqNumber++);
+	// Use the current seq, don't advance it here: the next seq comes from the device's ACK
+	// (handled below), so if this frame goes unanswered its seq is simply reused on the next call.
+	auto data = CommandSerializer::packageDataForBt(bytes, DATA_TYPE::DATA_MDR, this->_seqNumber);
 	this->_connector->send(data.data(), data.size());
 
 	// The device replies with an ACK and then the RET frame; unrelated notifications may interleave.
@@ -92,8 +96,19 @@ Buffer BluetoothWrapper::sendCommandAndReadResponse(const std::vector<char>& byt
 
 void BluetoothWrapper::_waitForAck()
 {
-	auto msg = this->_readMessage();
-	this->_seqNumber = msg.seqNumber;
+	// The device may send its own DATA_MDR notifications (already ACKed inside _readMessage) before
+	// the ACK for our frame arrives; skip those and keep reading until we see the actual ACK, so
+	// _seqNumber never gets set from an unrelated message's seq.
+	for (int i = 0; i < 16; i++)
+	{
+		auto msg = this->_readMessage();
+		if (msg.dataType == DATA_TYPE::ACK)
+		{
+			this->_seqNumber = msg.seqNumber;
+			return;
+		}
+	}
+	throw RecoverableException("No ACK received from device", true);
 }
 
 CommandSerializer::Message BluetoothWrapper::_readMessage()
@@ -150,9 +165,10 @@ CommandSerializer::Message BluetoothWrapper::_readMessage()
 
 	auto msg = CommandSerializer::unpackBtMessage(msgBytes);
 
-	// The device retransmits any DATA_MDR frame it sends until the host ACKs it. The ack carries the
-	// toggled 1-bit sequence number (1 - deviceSeq), matching the device's own ack-to-us behaviour.
-	if (msg.dataType == DATA_TYPE::DATA_MDR)
+	// The device retransmits any DATA_MDR or DATA_MDR_NO2 frame it sends until the host ACKs it (e.g.
+	// slider drags are echoed as DATA_MDR_NO2). The ack carries the toggled 1-bit sequence number
+	// (1 - deviceSeq), matching the device's own ack-to-us behaviour.
+	if (msg.dataType == DATA_TYPE::DATA_MDR || msg.dataType == DATA_TYPE::DATA_MDR_NO2)
 	{
 		auto ack = CommandSerializer::packageDataForBt({}, DATA_TYPE::ACK, (unsigned char)(1 - msg.seqNumber));
 		this->_connector->send(ack.data(), ack.size());