codesanitize

You possibly can wrap TableCalendar inside a showCupertinoModalPopup

Future showCupertinoCalendarPicker(BuildContext context) {
  DateTime selectedDate = DateTime.now();
  DateTime focusedDate = DateTime.now();

  return showCupertinoModalPopup(
    context: context,
    builder: (ctx) {
      return Container(
        peak: 500,
        ornament: const BoxDecoration(
          shade: Colour.fromARGB(255, 18, 18, 18),
          borderRadius: BorderRadius.vertical(high: Radius.round(20)),
        ),
        baby: Column(
          kids: [
            Row(
              children: [
                CupertinoButton(
                  onPressed: () => Navigator.of(ctx).pop(),
                  child: const Text(
                    'Cancel',
                    style: TextStyle(color: CupertinoColors.activeBlue),
                  ),
                ),
                const Spacer(),
                const Text(
                  'Edit Date',
                  style: TextStyle(
                    color: CupertinoColors.white,
                    fontWeight: FontWeight.bold,
                  ),
                ),
                const Spacer(),
                CupertinoButton(
                  onPressed: () => Navigator.of(ctx).pop(selectedDate),
                  child: const Text(
                    'Done',
                    style: TextStyle(color: CupertinoColors.activeBlue),
                  ),
                ),
              ],
            ),
            const SizedBox(peak: 8),
            const Textual content(
              'SELECT CUSTOM DATE',
              type: TextStyle(
                shade: CupertinoColors.systemGrey,
                fontSize: 13,
              ),
            ),
            Expanded(
              baby: SingleChildScrollView(
                baby: TableCalendar(
                  firstDay: DateTime.utc(2000, 1, 1),
                  lastDay: DateTime.utc(2100, 12, 31),
                  focusedDay: focusedDate,
                  selectedDayPredicate: (day) =>
                      day.12 months == selectedDate.12 months &&
                      day.month == selectedDate.month &&
                      day.day == selectedDate.day,
                  onDaySelected: (chosen, centered) {
                    selectedDate = chosen;
                    focusedDate = centered;
                  },
                  calendarFormat: CalendarFormat.month,
                  headerStyle: const HeaderStyle(
                    formatButtonVisible: false,
                    titleCentered: true,
                    leftChevronIcon: Icon(
                      CupertinoIcons.left_chevron,
                      shade: CupertinoColors.activeBlue,
                      dimension: 18,
                    ),
                    rightChevronIcon: Icon(
                      CupertinoIcons.right_chevron,
                      shade: CupertinoColors.activeBlue,
                      dimension: 18,
                    ),
                    titleTextStyle: TextStyle(
                      shade: CupertinoColors.white,
                      fontWeight: FontWeight.w600,
                    ),
                  ),
                  daysOfWeekStyle: const DaysOfWeekStyle(
                    weekdayStyle: TextStyle(
                      shade: CupertinoColors.systemGrey2,
                    ),
                    weekendStyle: TextStyle(
                      shade: CupertinoColors.systemGrey2,
                    ),
                  ),
                  calendarStyle: const CalendarStyle(
                    outsideDaysVisible: false,
                    todayDecoration: BoxDecoration(
                      shade: CupertinoColors.systemGrey,
                      form: BoxShape.circle,
                    ),
                    selectedDecoration: BoxDecoration(
                      shade: CupertinoColors.activeBlue,
                      form: BoxShape.circle,
                    ),
                    defaultTextStyle: TextStyle(
                      shade: CupertinoColors.white,
                    ),
                    weekendTextStyle: TextStyle(
                      shade: CupertinoColors.white,
                    ),
                    disabledTextStyle: TextStyle(
                      shade: CupertinoColors.systemGrey4,
                    ),
                  ),
                ),
              ),
            ),
          ],
        ),
      );
    },
  );
}

I’ve a horizontally scrolling UICollectionView in Swift.
Inside scrollViewDidScroll, I apply a rotation and scale rework to seen cells to create a card-tilt impact.

The difficulty:
If I double-tap or use two fingers on the gathering view throughout scrolling, the gathering view turns into “frozen” — it stops responding to swipe gestures, and the centered cell stays caught in place till I reload knowledge.

It looks as if making use of a rework in scrollViewDidScroll interferes with the gathering view’s contact dealing with and hit-testing, however I can’t work out easy methods to forestall it with out eradicating the rework impact.

How can I preserve the rework impact and stop the gathering view from freezing after multi-touch or double-tap?

func scrollViewDidScroll(_ scrollView: UIScrollView) {
        guard let collectionView = scrollView as? UICollectionView else { return }
        
        for cell in collectionView.visibleCells {
            // 1. Calculate the cell's horizontal distance from the middle of the display
            let centerX = view.bounds.width / 2
            let cellCenter = collectionView.convert(cell.middle, to: view)
            let distance = centerX - cellCenter.x
            
            // 2. Calculate rotation and scale based mostly on this distance
            // The farther from the middle, the extra it rotates and shrinks.
            let maxDistance = collectionView.bounds.width / 2
            let normalizedDistance = distance / maxDistance // Worth from -1 to 1
            
            let maxAngle = CGFloat.pi / 30 // A refined angle (e.g., 6 levels)
            let angle = maxAngle * normalizedDistance
            
            let minScale: CGFloat = 0.9
            let scale = 1.0 - (abs(normalizedDistance) * (1.0 - minScale))
            
            // 3. Apply the rework
            UIView.animate(withDuration: 0.3, delay: 0, choices: [.beginFromCurrentState, .allowUserInteraction], animations: {
                cell.rework = CGAffineTransform(rotationAngle: angle).scaledBy(x: scale, y: scale)
            }, completion: nil)
            
        }
        // ✅ Set preliminary centered index as soon as after format go
        if !hasSetInitialCenteredIndex {
            hasSetInitialCenteredIndex = true
            DispatchQueue.predominant.asyncAfter(deadline: .now() + 0.05) {
                self.snapToNearestCell()
                self.applyTransformToVisibleCells()
            }
        }
    }
    
    func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
        
        self.cardsCollectionView.isUserInteractionEnabled = false
        
        isScrolling = true
        
        let velocity = scrollView.panGestureRecognizer.velocity(in: scrollView)
        currentScrollDirection = velocity.x == 0 ? 0 : (velocity.x > 0 ? 1 : -1)
        
    }
    
    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
        
        self.cardsCollectionView.isUserInteractionEnabled = true
        
        isScrolling = false
        
        let pageWidth = scrollView.body.measurement.width
        let currentPage = Int((scrollView.contentOffset.x + pageWidth / 2) / pageWidth)
        
        if currentPage == 0 {
            let indexPath = IndexPath(merchandise: infinitePlaceholderArray.rely - 2, part: 0)
            cardsCollectionView.scrollToItem(at: indexPath, at: .centeredHorizontally, animated: false)
            
            // Delay snapping till format is corrected
            DispatchQueue.predominant.asyncAfter(deadline: .now() + 0.01) {
                self.snapToNearestCell()
                UIView.animate(withDuration: 0.3) {
                    self.applyTransformToVisibleCells()
                }
            }
            return
            
        } else if currentPage == infinitePlaceholderArray.rely - 1 {
            let indexPath = IndexPath(merchandise: 1, part: 0)
            cardsCollectionView.scrollToItem(at: indexPath, at: .centeredHorizontally, animated: false)
            
            // Delay snapping
            DispatchQueue.predominant.asyncAfter(deadline: .now() + 0.01) {
                self.snapToNearestCell()
                UIView.animate(withDuration: 0.3) {
                    self.applyTransformToVisibleCells()
                }
            }
            return
        }
        
        // No wrapping, snap usually
        snapToNearestCell()
        UIView.animate(withDuration: 0.3) {
            self.applyTransformToVisibleCells()
        }
    }
    
    func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
        if !decelerate {
            
            self.cardsCollectionView.isUserInteractionEnabled = true
            
            isScrolling = false
            
            snapToNearestCell()
            UIView.animate(withDuration: 0.3) {
                self.applyTransformToVisibleCells()
            }
        }
    }
    
    func setupInfiniteDataSource() {
        // Ensure you have knowledge to work with
        guard !placeholderArray.isEmpty else { return }
        
        // [Last Item] + [All Original Items] + [First Item]
        infinitePlaceholderArray.append(placeholderArray.final!)
        infinitePlaceholderArray.append(contentsOf: placeholderArray)
        infinitePlaceholderArray.append(placeholderArray.first!)
    }
    
    func applyTransformToVisibleCells() {
        guard let collectionView = cardsCollectionView else { return }
        
        for cell in collectionView.visibleCells {
            let centerX = view.bounds.width / 2
            let cellCenter = collectionView.convert(cell.middle, to: view)
            let distance = centerX - cellCenter.x
            
            let maxDistance = collectionView.bounds.width / 2
            let normalizedDistance = distance / maxDistance
            
            let maxAngle = CGFloat.pi / 30
            let angle = maxAngle * normalizedDistance
            
            let minScale: CGFloat = 0.9
            let scale = 1.0 - (abs(normalizedDistance) * (1.0 - minScale))
            
            cell.rework = CGAffineTransform(rotationAngle: angle).scaledBy(x: scale, y: scale)
        }
    }

    non-public func snapToNearestCell() {
        guard let collectionView = cardsCollectionView else { return }
        
        let centerX = collectionView.bounds.measurement.width / 2 + collectionView.contentOffset.x
        
        var closestIndexPath: IndexPath?
        var closestDistance: CGFloat = .greatestFiniteMagnitude
        
        for cell in collectionView.visibleCells {
            let cellCenterX = cell.middle.x
            let distance = abs(cellCenterX - centerX)
            if distance < closestDistance {
                closestDistance = distance
                closestIndexPath = collectionView.indexPath(for: cell)
            }
        }
        
        if let indexPath = closestIndexPath {
            currentlyCenteredIndexPath = indexPath  // Observe centered cell
            collectionView.scrollToItem(at: indexPath, at: .centeredHorizontally, animated: true)
        }
        
    }
    
    non-public func handleInfiniteScrollWrapping(for scrollView: UIScrollView) {
        let pageWidth = scrollView.body.measurement.width
        let currentPage = Int(flooring((scrollView.contentOffset.x - pageWidth / 2) / pageWidth) + 1)
        
        if currentPage == 0 {
            let targetIndexPath = IndexPath(merchandise: infinitePlaceholderArray.rely - 2, part: 0)
            cardsCollectionView.scrollToItem(at: targetIndexPath, at: .centeredHorizontally, animated: false)
        } else if currentPage == infinitePlaceholderArray.rely - 1 {
            let targetIndexPath = IndexPath(merchandise: 1, part: 0)
            cardsCollectionView.scrollToItem(at: targetIndexPath, at: .centeredHorizontally, animated: false)
        }
    }
}

I attempted:

• Detecting a number of touches in touchesBegan and calling my snapToNearestCell() technique to pressure snapping.

• Quickly disabling isUserInteractionEnabled on the gathering view throughout snap animations.

• Forcing scrollViewWillEndDragging and scrollViewDidEndDecelerating logic to run manually after multi-touch.

Anticipated:
The gathering view ought to snap to the closest cell after a multi-touch occasion and stay scrollable as regular.

Precise end result:
After a double-tap or two-finger contact whereas scrolling, the gathering view turns into caught. Scrolling stops working fully, and I’ve to reload the gathering view to revive interplay.

I am struggling to ship a communication notification (with the sender’s avatar and his identify). I am making a shopper software for a third-party web site the place sending Push notifications shouldn’t be applied. In consequence, I exploit native notification sending. I discovered little or no info on the Web about these notifications, however the code I discovered would not work for me.

The query is, can communication notifications be despatched solely by Push notifications? If that’s the case, this subject might be thought of closed. If not, why do I’ve an everyday notification despatched, though I turned on the required Capabilities and added Message Intent to Data.plist.

To make clear, I haven’t got a backend server. I am simply asking if notifications with an avatar and speak to identify (communication notifications) work just for Push notifications? I am unable to ship a push, solely a neighborhood notification. BUT I am unable to fashion the native notification below the message fashion with the contact identify and avatar.

func didReceive(
    request: UNNotificationRequest,
    withContentHandler contentHandler: @escaping (UNNotificationContent
    ) -> Void) {
    let deal with = INPersonHandle(worth: "unique-user-id)", sort: .unknown)
    let sender = INPerson(personHandle: deal with,
                                  nameComponents: nil,
                                  displayName: "Title",
                                  picture: nil, // right here you'll be able to present UIImage for consumer avatar
                                  contactIdentifier: nil,
                                  customIdentifier: "unique-user-id")
    
    let intent = INSendMessageIntent(
        recipients: nil,
        outgoingMessageType: .outgoingMessageText,
        content material: "content material of message",
        speakableGroupName: nil,
        conversationIdentifier: "unique-user-id-conv",
        serviceName: nil,
        sender: sender,
        attachments: nil
    )
    
    let interplay = INInteraction(intent: intent, response: nil)
    
    interplay.path = .incoming
    
    interplay.donate(completion: nil)
    
    let content material = request.content material
    
    do {
        let updatedContent = strive content material.updating(from: intent)
        let mutableBestAttemptContent = (updatedContent.mutableCopy() as? UNMutableNotificationContent)!
        mutableBestAttemptContent.threadIdentifier = "Thread-identifier" // use this subject for grouping notifications
        mutableBestAttemptContent.userInfo = request.content material.userInfo
        
        contentHandler(mutableBestAttemptContent)
        
    } catch {
        // Deal with errors that will happen whereas updating content material.
    }
}