Dynamic Addition and Removal of UIView in Swift: Implementation and Optimization Based on Gesture Recognition

Problem Background and Original Implementation Analysis

In iOS app development, dynamically managing user interface elements is a common requirement. Developers often need to add or remove views at runtime in response to user interactions or application state changes. The original problem describes a typical scenario: implementing the addition and removal of a UIView subview with a single tap operation. The original code attempted to use the touchesBegan method to handle touch events but encountered issues with the removal functionality.

The original code for adding a view is as follows:

var testView: UIView = UIView(frame: CGRectMake(0, 0, 320, 568))
testView.backgroundColor = UIColor.blueColor()
testView.alpha = 0.5
testView.tag = 100
super.view.userInteractionEnabled = false
self.view.userInteractionEnabled = true
self.view.addSubview(testView)

This code creates a blue semi-transparent view and sets its tag to 100. However, the line super.view.userInteractionEnabled = false is problematic as it disables interaction for the parent view, potentially preventing touch events from being properly delivered.

The original removal code used the touchesBegan method:

override func touchesBegan(touches: NSSet, withEvent event: UIEvent) {
    let touch = touches.anyObject() as UITouch
    let point = touch.locationInView(self.view)
    
    if(testView.tag==100){
        println("Tag 100")
        testView.removeFromSuperview()
    }
    else{
        println("tag not found")
    }
}

The main issue here is that testView is a local variable and cannot be directly accessed within the touchesBegan method. Even when attempting to find the view by tag, the original code does not correctly use the viewWithTag method, resulting in the view not being found and removed.

Solution: Optimized Implementation Based on Gesture Recognition

The best answer provides a more reliable solution: using UITapGestureRecognizer to handle tap events. This approach aligns better with iOS event handling paradigms and is easier to maintain than directly overriding touchesBegan.

The complete Swift implementation code is as follows:

@IBAction func infoView(sender: UIButton) {
    var testView: UIView = UIView(frame: CGRectMake(0, 0, 320, 568))
testView.backgroundColor = UIColor.blueColor()
testView.alpha = 0.5
testView.tag = 100
testView.userInteractionEnabled = true
self.view.addSubview(testView)

    let aSelector : Selector = "removeSubview"
    let tapGesture = UITapGestureRecognizer(target:self, action: aSelector)
    testView.addGestureRecognizer(tapGesture)
}

func removeSubview(){
    println("Start remove sibview")
    if let viewWithTag = self.view.viewWithTag(100) {
        viewWithTag.removeFromSuperview()
    }else{
        println("No!")
    }
}

The core advantages of this solution include:

1. Correct Use of the View Tag System: Using the viewWithTag(100) method to find views with specific tags within the view hierarchy is the standard practice for managing view references in iOS.
2. Integration of Gesture Recognizers: UITapGestureRecognizer provides more precise handling of tap events, avoiding potential touch event conflicts present in the original method.
3. Proper Configuration of View Interaction: By setting testView.userInteractionEnabled = true, it ensures that the gesture recognizer can correctly receive events.

Swift 3+ Syntax Updates

As the Swift language evolves, so does its syntax. Here is the updated version for Swift 3+:

@IBAction func infoView(sender: UIButton) {
    let testView: UIView = UIView(frame: CGRect(x: 0, y: 0, width: 320, height: 568))
testView.backgroundColor = .blue
testView.alpha = 0.5
testView.tag = 100
testView.isUserInteractionEnabled = true
self.view.addSubview(testView)

    let aSelector : Selector = #selector(GasMapViewController.removeSubview)
    let tapGesture = UITapGestureRecognizer(target:self, action: aSelector)
    testView.addGestureRecognizer(tapGesture)
}

func removeSubview(){
    print("Start remove sibview")
    if let viewWithTag = self.view.viewWithTag(100) {
        viewWithTag.removeFromSuperview()
    }else{
        print("No!")
    }
}

Key changes include:

• CGRectMake replaced with the more Swift-style CGRect(x:y:width:height:)
• UIColor.blueColor() simplified to .blue
• userInteractionEnabled property renamed to isUserInteractionEnabled
• Selector syntax updated to #selector(ClassName.methodName), providing compile-time type checking
• println unified to print

Alternative Solutions and In-Depth Analysis

Other answers provide improved versions based on the original touchesBegan approach:

override func touchesBegan(touches: NSSet, withEvent event: UIEvent) {
    let touch = touches.anyObject() as UITouch
    let point = touch.locationInView(self.view)

    if let viewWithTag = self.view.viewWithTag(100) {
        print("Tag 100")
        viewWithTag.removeFromSuperview()
    } else {
        print("tag not found")
    }
}

This solution corrects the key error in the original code: properly finding the view using the viewWithTag method instead of relying on potentially unavailable local variable references. However, this approach still has limitations:

1. It affects the entire view controller's touch event handling, potentially interfering with other interactive elements.
2. Lacks fine-grained control over gestures, such as tap count or number of fingers.
3. Touch event handling can become complex and error-prone in intricate view hierarchies.

Best Practices and Performance Considerations

In practical development, beyond functional implementation, the following best practices should be considered:

Memory Management: After a view is removed, ensure no strong references are retained so the system can properly reclaim memory. When using gesture recognizers, be mindful of avoiding retain cycles.

View Reuse: For views that are frequently added and removed, consider implementing a view reuse mechanism instead of creating new instances each time.

Animation Support: To enhance user experience, consider adding animation effects when adding and removing views:

// Fade-in animation when adding a view
UIView.animateWithDuration(0.3) {
    testView.alpha = 0.5
}

// Fade-out animation when removing a view
UIView.animateWithDuration(0.3, animations: {
    viewWithTag.alpha = 0.0
}) { completed in
    if completed {
        viewWithTag.removeFromSuperview()
    }
}

Error Handling and Logging: In production environments, implement more robust error handling and logging, especially when view lookup fails.

Conclusion

Through the analysis in this article, we can see that implementing dynamic addition and removal of UIView in Swift requires consideration of multiple factors: proper view reference management, appropriate event handling mechanisms, and up-to-date syntax. The gesture recognition-based solution not only addresses the original problem but also offers better maintainability and extensibility. Developers should choose the most suitable implementation based on specific requirements while adhering to iOS development best practices to create efficient and reliable user interfaces.