There is, unfortunately, no publicly–documented, supported way in iOS to subscribe to “ringer-switch changed” events. Apple deliberately hides the position of that switch from third‐party apps. Under the hood the phone does generate internal GSEvents (kGSEventRingerOff / kGSEventRingerOn) and SpringBoard even posts a Darwin/notify notification, but none of those are in the public SDK and any reliance on them is at your own App-Store-risk.

What you can do in practice falls into two camps:

1. “Pure public‐API” hack: play a very short silent SystemSoundID or AVAudioPlayer sound, measure how long it actually “played,” and from that infer mute vs. ring. By chaining these ultra-short silent‐sound plays you can turn polling into virtually an “event” stream and post your own NSNotification as soon as you see a change.

2. Private‐API listening:
   • GSEventRef hooks (GraphicsServices) for kGSEventRingerOff/On
   • or Darwin notifications (notify_register_dispatch) on the key that SpringBoard uses internally—e.g. “com.apple.springboard.ringerstate” (or very similar)

All of these will get you private-API usage and may get you rejected if Apple decides to scan for it. If you are really prepared to run it by Apple and get explicit approval you can do the private-API route; otherwise, go with the silent-sound trick.

————————————————————————

1. Public-API “silent-sound” approach
   ­————————————————
   • Bundle a very short (say, 0.1 sec) completely silent CAF or CAF file.
   • Create a SystemSoundID for it.
   • Every time you want to know the switch position play that sound and hook its completion callback.
   • If you are in RING mode the sound will actually play for your full duration (and the completion will come ~0.1 sec later).
   If you are in SILENT mode the system will drop it immediately and your completion handler will fire almost instantly.

Sample code (Objective-C):

// RingSilentSwitchWatcher.h
@interface RingSilentSwitchWatcher : NSObject
@property (nonatomic, readonly) BOOL isSilent;
+ (instancetype)sharedWatcher;
@end

// RingSilentSwitchWatcher.m
#import "RingSilentSwitchWatcher.h"
#import <AudioToolbox/AudioToolbox.h>
#import <QuartzCore/QuartzCore.h>   // for CACurrentMediaTime()

static const NSTimeInterval kTestSoundDuration = 0.1;

@interface RingSilentSwitchWatcher ()
@property (nonatomic, assign) SystemSoundID soundID;
@property (nonatomic, assign) CFTimeInterval lastStart;
@property (nonatomic, readwrite) BOOL isSilent;
@end

@implementation RingSilentSwitchWatcher

+ (instancetype)sharedWatcher {
  static RingSilentSwitchWatcher *s_shared = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    s_shared = [[self alloc] init];
  });
  return s_shared;
}

- (instancetype)init {
  self = [super init];
  if (!self) return nil;

  // load our tiny silent file
  NSURL *caf = [[NSBundle mainBundle] URLForResource:@"silent" withExtension:@"caf"];
  AudioServicesCreateSystemSoundID((__bridge CFURLRef)caf, &_soundID);
  AudioServicesAddSystemSoundCompletion(_soundID, NULL, NULL,
                                        soundCompletionCallback,
                                        (__bridge void*)self);

  // kick off the chain
  [self _scheduleTestImmediately];
  return self;
}

void soundCompletionCallback(SystemSoundID ssID, void *clientData) {
  RingSilentSwitchWatcher *self = (__bridge RingSilentSwitchWatcher*)clientData;
  CFTimeInterval elapsed = CACurrentMediaTime() - self.lastStart;
  BOOL nowSilent = (elapsed < (kTestSoundDuration * 0.5));
  if (nowSilent != self.isSilent) {
    self.isSilent = nowSilent;
    // broadcast your own notification
    [[NSNotificationCenter defaultCenter]
        postNotificationName:@"RingSilentSwitchChangedNotification"
                      object:@(self.isSilent)];
  }
  // immediately chain the next test
  [self _scheduleTestImmediately];
}

- (void)_scheduleTestImmediately {
  self.lastStart = CACurrentMediaTime();
  AudioServicesPlaySystemSound(self.soundID);
}

@end

­Advantages:
­ § Uses only public AudioToolbox/QuartzCore.
­ § Can be submitted to the App Store.
­ § By chaining tests you effectively get “instantly” notified of switch flips.

­Drawbacks:
­ § Still a hacky timer/poll under the covers.
­ § Plays a ton of silent sounds (though imperceptible).

———————————————————————

2. Private-API Darwin/notify or GSEventRef hooks
   ­————————————————————————————
   If you do decide to risk using private APIs you can either:

A) GSEventRef callback (GraphicsServices)
– Link against GraphicsServices.framework (undocumented).
– Intercept kGSEventRingerOff (1012) and kGSEventRingerOn (1013).

 ```objc
 #import <GraphicsServices/GraphicsServices.h>

 static void _ringerChanged(GSEventRef event, void *ctx) {
   int type = GSEventGetType(event);
   BOOL nowSilent = (type == kGSEventRingerOff);
   // post your notification or update UI…
 }

 // somewhere on startup:
 GSEventRegisterEventCallback(_ringerChanged, NULL);
 ```

B) Darwin notify on SpringBoard’s ringer notification
– SpringBoard posts a notify via notify_post(“com.apple.springboard.ringerstate”, …)
– You can subscribe with notify_register_dispatch:

 ```objc
 #import <notify.h>

 static int    sRingerToken = 0;

 - (void)startObservingRingerState {
   // the actual key may vary by iOS version; you have to dump SpringBoard’s notify posts
   const char *key = "com.apple.springboard.ringerstate";
   notify_register_dispatch(key,
                            &sRingerToken,
                            dispatch_get_main_queue(),
                            ^(int token) {
     uint64_t state = 0;
     notify_get_state(token, &state);
     BOOL nowSilent = (state == 0);
     // post your own NSNotification…
   });
 }
 ```

­Advantages:
­ § Truly event‐based, very low overhead.

­Drawbacks:
­ § Undocumented, private.
­ § Apple may reject your binary.
­ § The key names and even the existence of these events can change any iOS release.

——————————————
Conclusion
————
If you want to play it completely safe in the App Store, your only route is the “silent‐sound” polling hack (option 1). If you have an MFi or enterprise‐only scenario, you can experiment with the private hooks in option 2—but be prepared to justify it to Apple (and to fix it the day it breaks in a new iOS).