components/private/Overlay/src/MDCOverlayObserver.m

// Copyright 2016-present the Material Components for iOS authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#import "MDCOverlayObserver.h"

#import <CoreFoundation/CoreFoundation.h>
#import <CoreGraphics/CoreGraphics.h>
#import <UIKit/UIKit.h>

#import "MDCOverlayImplementor.h"
#import "private/MDCOverlayAnimationObserver.h"
#import "private/MDCOverlayObserverOverlay.h"
#import "private/MDCOverlayObserverTransition.h"

// If this is ever required elsewhere in the code, just disable unused parameter warnings entirely
// with -Wno-unused-params.
#ifdef NS_BLOCK_ASSERTIONS
#define MDC_UNUSED_IN_RELEASE __unused
#else
#define MDC_UNUSED_IN_RELEASE
#endif

@interface MDCOverlayObserver () <MDCOverlayAnimationObserverDelegate>

/** The list of overlays currently known to this observer. */
@property(nonatomic) NSMutableDictionary *overlays;

/** The currently-pending transition. */
@property(nonatomic) MDCOverlayObserverTransition *pendingTransition;

/** The table holding the target-action mapping. */
@property(nonatomic) NSMapTable *actionTable;

/** The animation observer used to coalesce events. */
@property(nonatomic, strong) MDCOverlayAnimationObserver *observer;

@end

@implementation MDCOverlayObserver

static MDCOverlayObserver *_sOverlayObserver;

// This class must be available before the keyboard (or any other overlay contributor) has a chance
// to report overlay changes. The +load method is the only safe place early enough.
+ (void)load {
  @autoreleasepool {
    _sOverlayObserver = [[MDCOverlayObserver alloc] init];
  }
}

+ (instancetype)observerForScreen:(MDC_UNUSED_IN_RELEASE UIScreen *)screen {
  NSParameterAssert(screen == nil || screen == [UIScreen mainScreen]);
  return _sOverlayObserver;
}

- (instancetype)init {
  self = [super init];
  if (self != nil) {
    _overlays = [NSMutableDictionary dictionary];
    _observer = [[MDCOverlayAnimationObserver alloc] init];
    _observer.delegate = self;

    // Set up the target/action table. The keys will be weak pointers to objects, with no calls to
    // hashing done only on the pointer address (as opposed to calling -hash/-isEqual:).
    // The values will be strong references to objects.
    NSPointerFunctionsOptions keyOptions =
        (NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPointerPersonality);
    NSPointerFunctionsOptions valueOptions =
        (NSPointerFunctionsStrongMemory | NSPointerFunctionsObjectPersonality);
    _actionTable = [NSMapTable mapTableWithKeyOptions:keyOptions valueOptions:valueOptions];

    // Register to hear when an overlay changes.
    [[NSNotificationCenter defaultCenter] addObserver:self
                                             selector:@selector(handleOverlayChangeNotification:)
                                                 name:MDCOverlayDidChangeNotification
                                               object:nil];
  }
  return self;
}

#pragma mark - Overlays

- (MDCOverlayObserverOverlay *)overlayWithIdentifier:(NSString *)identifier {
  return self.overlays[identifier];
}

- (MDCOverlayObserverOverlay *)buildOverlayWithIdentifier:(NSString *)identifier {
  MDCOverlayObserverOverlay *overlay = self.overlays[identifier];
  if (overlay == nil) {
    overlay = [[MDCOverlayObserverOverlay alloc] init];
    overlay.identifier = identifier;
    self.overlays[identifier] = overlay;
  }

  return overlay;
}

- (void)removeOverlayWithIdentifier:(NSString *)identifier {
  [self.overlays removeObjectForKey:identifier];
}

- (NSArray *)sortedOverlays {
  NSArray *sortedKeys = [[self.overlays allKeys] sortedArrayUsingSelector:@selector(compare:)];

  NSMutableArray *result = [NSMutableArray array];
  for (NSString *key in sortedKeys) {
    [result addObject:self.overlays[key]];
  }

  return result;
}

#pragma mark - Input Sources

- (BOOL)updateOverlay:(NSString *)identifier withFrame:(CGRect)frame {
  BOOL changed = NO;

  MDCOverlayObserverOverlay *existingOverlay = [self overlayWithIdentifier:identifier];

  if (existingOverlay != nil) {
    if (CGRectIsEmpty(frame)) {
      // We're getting rid of this overlay entirely.
      [self removeOverlayWithIdentifier:identifier];
      changed = YES;
    } else if (!CGRectEqualToRect(existingOverlay.frame, frame)) {
      // We're changing to a new frame for this overlay.
      existingOverlay.frame = frame;
      changed = YES;
    }
  } else if (!CGRectIsEmpty(frame)) {
    MDCOverlayObserverOverlay *overlay = [self buildOverlayWithIdentifier:identifier];
    overlay.frame = frame;
    changed = YES;
  }

  return changed;
}

- (void)handleOverlayChangeNotification:(NSNotification *)note {
  NSDictionary *userInfo = note.userInfo;
  NSString *identifier = userInfo[MDCOverlayIdentifierKey];

  // Don't even bother if an identifier wasn't provided.
  if (identifier.length == 0) {
    return;
  }

  NSValue *frame = userInfo[MDCOverlayFrameKey] ? userInfo[MDCOverlayFrameKey]
                                                : [NSValue valueWithCGRect:CGRectNull];
  NSNumber *duration = userInfo[MDCOverlayTransitionDurationKey];

  // Update the overlay frame.
  BOOL updated = [self updateOverlay:identifier withFrame:[frame CGRectValue]];

  // If there was actually a change, set up a transition.
  if (updated) {
    if (self.pendingTransition == nil) {
      self.pendingTransition = [[MDCOverlayObserverTransition alloc] init];
      [self.observer messageDelegateOnNextRunloop];
    }
  }

  // If we were given a duration, then update the animation parameters.
  if (self.pendingTransition != nil && duration != nil) {
    self.pendingTransition.duration = duration.doubleValue;
    self.pendingTransition.customTimingFunction = userInfo[MDCOverlayTransitionTimingFunctionKey];
    self.pendingTransition.animationCurve =
        ((NSNumber *)userInfo[MDCOverlayTransitionCurveKey]).integerValue;

    // If this update requires us to run the animation immediately, go ahead and fire it off.
    NSNumber *runImmediately = userInfo[MDCOverlayTransitionImmediacyKey];
    if (runImmediately.boolValue) {
      [self fireTransition];
    }
  }
}

#pragma mark - Target/Action

- (NSInvocation *)buildInvocationForTarget:(id)target action:(SEL)action {
  NSMethodSignature *signature = [target methodSignatureForSelector:action];
  NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
  [invocation setTarget:target];
  [invocation setSelector:action];

  return invocation;
}

- (void)invokeTarget:(NSInvocation *)invocation
      withTransition:(MDCOverlayObserverTransition *)transition {
  NSParameterAssert(invocation != nil);
  NSParameterAssert(transition != nil);

  [invocation setArgument:&transition atIndex:2];
  [invocation invoke];
}

- (NSUInteger)indexOfInvocationForTarget:(id)target action:(SEL)action {
  NSMutableArray *invocations = [self.actionTable objectForKey:target];

  if (invocations == nil) {
    return NSNotFound;
  }

  return [invocations indexOfObjectPassingTest:^BOOL(NSInvocation *invocation,
                                                     __unused NSUInteger idx, __unused BOOL *stop) {
    return invocation.selector == action;
  }];
}

- (void)addTarget:(id)target action:(SEL)action {
  NSParameterAssert(target != nil);

  NSUInteger foundIndex = [self indexOfInvocationForTarget:target action:action];
  if (foundIndex != NSNotFound) {
    return;
  }

  NSInvocation *invocation = [self buildInvocationForTarget:target action:action];
  NSParameterAssert(invocation != nil);

  NSMutableArray *invocations = [self.actionTable objectForKey:target];
  if (invocations == nil) {
    invocations = [NSMutableArray array];
    [self.actionTable setObject:invocations forKey:target];
  }

  [invocations addObject:invocation];

  if (self.overlays.count > 0) {
    // If there's already a pending transition, let the runloop take care of it, otherwise create
    // one and call it immediately on just the newly-added target, so that it can get its initial
    // value.
    if (self.pendingTransition == nil) {
      MDCOverlayObserverTransition *transition = [[MDCOverlayObserverTransition alloc] init];
      transition.overlays = [self sortedOverlays];

      [self invokeTarget:invocation withTransition:transition];

      // Run the (non-animated) transition.
      [transition runAnimation];
    }
  }
}

- (void)removeTarget:(id)target {
  NSParameterAssert(target != nil);

  [self.actionTable removeObjectForKey:target];
}

- (void)removeTarget:(id)target action:(SEL)action {
  NSParameterAssert(target != nil);

  NSUInteger foundIndex = [self indexOfInvocationForTarget:target action:action];

  if (foundIndex != NSNotFound) {
    NSMutableArray *invocations = [self.actionTable objectForKey:target];

    if (invocations.count == 1) {
      // Clean up all the invocations if this was the only one.
      [self removeTarget:target];
    } else {
      // Otherwise remove this single invocation.
      [invocations removeObjectAtIndex:foundIndex];
    }
  }
}

#pragma mark - Runloop Observer

- (void)fireTransition {
  if (self.pendingTransition == nil) {
    return;
  }

  // Update the transition with the latest set of overlays.
  self.pendingTransition.overlays = [self sortedOverlays];

  // Call all of our targets and let them know a transition has happened.
  for (id target in self.actionTable) {
    NSArray *invocations = [self.actionTable objectForKey:target];
    for (NSInvocation *invocation in invocations) {
      [self invokeTarget:invocation withTransition:self.pendingTransition];
    }
  }

  // Actually run the transition animation.
  [self.pendingTransition runAnimation];

  self.pendingTransition = nil;
}

- (void)animationObserverDidEndRunloop:(__unused MDCOverlayAnimationObserver *)observer {
  [self fireTransition];
}

@end