【问题标题】:iPhone: Incrementing the application badge through a local notificationiPhone:通过本地通知增加应用程序徽章
【发布时间】:2011-08-23 03:41:23
【问题描述】:

是否可以在应用未运行时通过本地通知增加应用徽章?

我知道如何设置徽章,但还没有找到任何方法来增加这个值。

localNotification.applicationIconBadgeNumber = 23;

更新:我找到了一个(远非完美的)解决方案。如果用户不打开应用并为每个 +1 事件添加通知,您可以预测会发生什么。

一个例子:

  • 对于第 1 天:计数 = 0
  • 对于第 2 天:localNotification.applicationIconBadgeNumber = 1;
  • 对于第 3 天:localNotification.applicationIconBadgeNumber = 2;
  • 第 4 天:localNotification.applicationIconBadgeNumber = 3;

==> 将这些通知放在一个数组中,并在应用程序退出之前设置它们。

但是,我正在寻找比这种解决方法更好的解决方案。

【问题讨论】:

    标签: iphone cocoa-touch ios4 push-notification uilocalnotification


    【解决方案1】:

    我已经找到、实施并测试了一种“解决方法”,用于(显然)自动增加应用图标的徽章编号,该方法适用于非重复本地通知

    当触发多个本地通知时,UILocalNotifications 确实不可能让 iOS“自动”更新/增加徽章编号,并且用户“忽略”它们或不立即处理它们,因此它们“堆积”在通知中心。

    此外,向您的应用程序“添加一些回调方法”不能处理“自动增量”,因为整个通知事情是由 iOS 在您的应用程序“外部”处理的,您的应用程序甚至不需要运行。

    但是有一些解决方法,这是基于我通过实验找到的知识,因为 XCode 文档对徽章属性过于模糊。

    • 徽章只是一个“整数”,实际上更像是在注册通知之前分配给 applicationIconBadgeNumber 属性的“虚拟标签”。您可以给它 any 值 - 当通知触发时,iOS 将向徽章添加 that 值,无论您在注册通知时设置什么值。 iOS 没有神奇的“自动增量”或其他操作(可能与推送通知不同,但这不是这里的主题)。 iOS 只是从注册的通知中获取数字(整数),并将其放入徽章中。

    因此,对于“解决方法”,您的应用必须已经为它新创建的每个通知提供正确的、递增的徽章编号,并在“待处理通知之上”注册。

    由于您的应用无法展望未来,并且知道您将立即处理哪些事件,以及哪些事件您将“等待”一段时间,因此有一些技巧可以做:

    当您的应用处理通知时(通过点击通知、图标等),您必须:

    1. 获取所有待处理通知的副本
    2. “重新编号”这些待处理通知的徽章编号
    3. 删除所有待处理通知
    4. 使用更正的徽章重新注册通知副本 再次编号

    此外,当您的应用注册新通知时,它必须首先检查有多少通知处于待处理状态,并使用以下方式注册新通知:

    badgeNbr = nbrOfPendingNotifications + 1;
    

    查看我的代码,它会变得更清晰。我对此进行了测试,它确实有效:

    在您的“registerLocalNotification”方法中,您应该这样做:

    NSUInteger nextBadgeNumber = [[[UIApplication sharedApplication] scheduledLocalNotifications] count] + 1;
    localNotification.applicationIconBadgeNumber = nextBadgeNumber;
    

    当您处理通知(appDelegate)时,您应该调用下面的方法,该方法清除图标上的标记并重新编号待处理通知的标记(如果有)

    请注意,下一个代码适用于“顺序”注册事件。如果您要在未决事件之间“添加”事件,则必须首先“重新排序”这些事件。我没有走那么远,但我认为这是可能的。

    - (void)renumberBadgesOfPendingNotifications
    {
        // clear the badge on the icon
        [[UIApplication sharedApplication] setApplicationIconBadgeNumber:0];
    
        // first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
        NSArray *pendingNotifications = [[UIApplication sharedApplication] scheduledLocalNotifications];
    
        // if there are any pending notifications -> adjust their badge number
        if (pendingNotifications.count != 0)
        {
            // clear all pending notifications
            [[UIApplication sharedApplication] cancelAllLocalNotifications];
    
            // the for loop will 'restore' the pending notifications, but with corrected badge numbers
            // note : a more advanced method could 'sort' the notifications first !!!
            NSUInteger badgeNbr = 1;
    
            for (UILocalNotification *notification in pendingNotifications)
            {
                // modify the badgeNumber
                notification.applicationIconBadgeNumber = badgeNbr++;
    
                // schedule 'again'
                [[UIApplication sharedApplication] scheduleLocalNotification:notification];
            }
        }
    }
    

    要真正做到“防弹”,此方法应该是“原子”(内核)代码,防止 iOS 在此方法执行期间触发通知。我们必须在这里冒这个险,发生这种情况的可能性很小。

    这是我对 Stackoverflow 的第一次贡献,如果我不遵守此处的“规则”,您也可以发表评论

    【讨论】:

    • +1 这是一个很棒而彻底的答案。这就是我们在 Stack Overflow 喜欢的答案。欢迎!
    • 为什么它适用于非重复通知?重复通知会发生什么?
    • “重复”通知实际上注册为单个通知,“repeatInterval”属性设置为所需值。对于单个(重复)通知,您只能为徽章属性 applicationIconBadgeNumber 设置一个值(请记住,根据我的解释,设置数字的是您,而不是 iOS)。因此,所有重复的通知都会显示相同的徽章 ID。猜猜没有解决方法。您最多可以注册 64 条通知。如果这足够了,您可以“愚弄”用户并以这种方式创建(最多 64 个)“重复”通知。
    • 这很好,但是当用户关闭通知(在通知中心)时如何减少数字?
    • 看看 '- (void)renumberBadgesOfPendingNotifications' :此函数通过删除所有待处理的通知并重新设置它们来“伪造”数字的减少。请注意,当您关闭通知时,您不能只“减少”徽章编号:当您点击通知时,iOS 只会删除徽章,无论它显示什么(1、2、3,...)。您实际上是在确认一个“或多个”通知。如果徽章显示“3”,则表示您在点击通知时确认了最后 3 个(错过的)通知。
    【解决方案2】:

    当您的应用程序未运行时,您能够动态设置徽章编号的唯一方法是使用推送通知。您必须在服务器端跟踪更新。

    【讨论】:

      【解决方案3】:

      基于documentation,我相信当您的应用程序未运行时,您无法增加徽章的值。您在安排通知时设置了徽章编号,因此无法增加它。

      应用程序负责管理其图标上显示的徽章编号。例如,如果文本消息应用程序在收到本地通知后处理所有传入消息,则应通过将 UIApplication 对象的 applicationIconBadgeNumber 属性设置为 0 来删除图标标志。

      【讨论】:

        【解决方案4】:

        在您的项目委托中添加以下代码。

        - (void)applicationDidEnterBackground:(UIApplication *)application
        {
            NSLog(@"%s",__FUNCTION__);
        
            NSArray *arrayOfLocalNotifications = [[UIApplication sharedApplication] scheduledLocalNotifications] ;
        
            for (UILocalNotification *localNotification in arrayOfLocalNotifications) {
                NSLog(@"the notification: %@", localNotification);
                localNotification.applicationIconBadgeNumber= application.applicationIconBadgeNumber+1;
            }
        }
        

        这对我有用。 :-)

        【讨论】:

        • 好吧,这只会在应用程序即将移至后台时更新 ApplicationIconBadgeNumber。如果您在应用处于后台时收到本地通知,则徽章编号将无法正确显示。
        【解决方案5】:

        Whasssaabhhh 在 Swift 2.1 中的回答,带排序

        func renumberBadgesOfPendingNotifications() {
            let app = UIApplication.sharedApplication()
            let pendingNotifications = app.scheduledLocalNotifications
        
            // clear the badge on the icon
            app.applicationIconBadgeNumber = 0
        
            // first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
            // if there are any pending notifications -> adjust their badge number
            if let pendings = pendingNotifications where pendings.count > 0 {
        
                // sorted by fire date.
                let notifications = pendings.sort({ p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .OrderedAscending })
        
                // clear all pending notifications
                app.cancelAllLocalNotifications()
        
                // the for loop will 'restore' the pending notifications, but with corrected badge numbers
                var badgeNumber = 1
                for n in notifications {
        
                    // modify the badgeNumber
                    n.applicationIconBadgeNumber = badgeNumber++
        
                    // schedule 'again'
                    app.scheduleLocalNotification(n)
                }
            }
        }
        

        【讨论】:

        • 这真是太聪明了。
        【解决方案6】:

        Whasssaaahhh 的回答对我很有帮助。我还需要根据通知的 fireDates 对通知进行排序。这是 Whasssaaahhh 的代码和我的代码,用于使用 NSArray 的委托方法对通知进行排序 - [NSArray sortedArrayUsingComparator:^(id obj1, id obj2) {}];

        - (void)renumberBadgesOfPendingNotifications
        {
            // clear the badge on the icon
            [[UIApplication sharedApplication] setApplicationIconBadgeNumber:0];
        
            // first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
            // Sort the pending notifications first by their fireDate
            NSArray *pendingNotifications = [[[UIApplication sharedApplication] scheduledLocalNotifications] sortedArrayUsingComparator:^(id obj1, id obj2) {
                if ([obj1 isKindOfClass:[UILocalNotification class]] && [obj2 isKindOfClass:[UILocalNotification class]])
                {
                    UILocalNotification *notif1 = (UILocalNotification *)obj1;
                    UILocalNotification *notif2 = (UILocalNotification *)obj2;
                    return [notif1.fireDate compare:notif2.fireDate];
                }
        
                return NSOrderedSame;
            }];
        
            // if there are any pending notifications -> adjust their badge number
            if (pendingNotifications.count != 0)
            {
                // clear all pending notifications
                [[UIApplication sharedApplication] cancelAllLocalNotifications];
        
                // the for loop will 'restore' the pending notifications, but with corrected badge numbers
                // note : a more advanced method could 'sort' the notifications first !!!
                NSUInteger badgeNbr = 1;
        
                for (UILocalNotification *notification in pendingNotifications)
                {
                    // modify the badgeNumber
                    notification.applicationIconBadgeNumber = badgeNbr++;
        
                    // schedule 'again'
                    [[UIApplication sharedApplication] scheduleLocalNotification:notification];
                }
            }
        }
        

        一段时间后,我需要在 Swift 上实现这一点,但还需要支持重复本地通知。我想出了一个关于 Swift 的解决方案。

        Swift 2.3 解决方案

        func renumberBadgesOfPendingNotifications() {
            let app = UIApplication.sharedApplication()
            let pendingNotifications = app.scheduledLocalNotifications
        
            // clear the badge on the icon
            app.applicationIconBadgeNumber = 0
        
            // first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
            // if there are any pending notifications -> adjust their badge number
            if let pendings = pendingNotifications where pendings.count > 0 {
        
                // Reassign firedate.
                var notifications = pendings
                var i = 0
                for notif in notifications {
                    if notif.fireDate?.compare(NSDate()) == NSComparisonResult.OrderedAscending &&
                    notif.repeatInterval.rawValue == NSCalendarUnit.init(rawValue:0).rawValue {
                        // Skip notification scheduled earlier than current date time
                        // and if it is has NO REPEAT INTERVAL
                    }
                    else {
                        notif.fireDate = getFireDate(notif)
                    }
        
                    i+=1
                }
        
                // sorted by fire date.
                notifications = pendings.sort({ p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .OrderedAscending })
        
                // clear all pending notifications
                app.cancelAllLocalNotifications()
        
                // the for loop will 'restore' the pending notifications, but with corrected badge numbers
                var badgeNumber: Int = 1
                for n in notifications {
                    // modify the badgeNumber
                    n.applicationIconBadgeNumber = badgeNumber
        
                    badgeNumber+=1
                    // schedule 'again'
                    app.scheduleLocalNotification(n)
                }
            }
        }
        
        private func getFireDate(notification:UILocalNotification?) -> NSDate? {
                if notification == nil {
                    return nil
                }
        
                let currentDate: NSDate = NSDate().dateByRemovingSeconds()
                let originalDate: NSDate = notification!.fireDate!
                var fireDate: NSDate? = originalDate
        
                if originalDate.compare(currentDate) == NSComparisonResult.OrderedAscending ||
                    originalDate.compare(currentDate) == NSComparisonResult.OrderedSame {
        
                    let currentDateTimeInterval = currentDate.timeIntervalSinceReferenceDate
                    let originalDateTimeInterval = originalDate.timeIntervalSinceReferenceDate
                    var frequency:NSTimeInterval = 0
        
                    switch notification?.repeatInterval {
                    case NSCalendarUnit.Hour?:
                        frequency = currentDate.dateByAddingHours(1).timeIntervalSinceDate(currentDate)
                        print(frequency)
                        break
                    case NSCalendarUnit.Day?:
                        frequency = currentDate.dateByAddingDays(1).timeIntervalSinceDate(currentDate)
                        print(frequency)
                        break
                    case NSCalendarUnit.WeekOfYear?:
                        frequency = currentDate.dateByAddingDays(7).timeIntervalSinceDate(currentDate)
                        print(frequency)
                        break
                    case NSCalendarUnit.Month?:
                        frequency = currentDate.dateByAddingMonths(1).timeIntervalSinceDate(currentDate)
                        print(frequency)
                        break
                    case NSCalendarUnit.Year?:
                        frequency = currentDate.dateByAddingYears(1).timeIntervalSinceDate(currentDate)
                        print(frequency)
                        break
                    default:
                        originalDate
                    }
        
                    let timeIntervalDiff = (((currentDateTimeInterval - originalDateTimeInterval) / frequency) + frequency) + originalDateTimeInterval
                    fireDate = NSDate(timeIntervalSinceReferenceDate: timeIntervalDiff)
                }
        
                return fireDate?.dateByRemovingSeconds()
            }
        

        注意:dateByAddingHours、dateByAddingHours、dateByAddingMonths、dateByAddingYears、dateByRemovingSeconds 是我正在使用的 DateExtension 中的方法,是您可以自行实现的自描述方法。

        【讨论】:

        • 请升级到 iOS 10 和 UserNotifications 框架。会很棒!
        【解决方案7】:

        从 iOS10 开始,可以直接在 UNMutableNotificationContent 上定义徽章编号。

        这对我有用:

        我正在开发一个基于日期添加通知的应用程序(使用 CalendarComponents),我的触发器是 UNCalendarNotificationTrigger。我的代码很简单:

        let content = UNMutableNotificationContent()
                content.title = "Title"
                content.body = "Your message"
                content.sound = .default()
                content.badge = NSNumber(value: UIApplication.shared.applicationIconBadgeNumber + 1)
        

        关于content.badge,文档说:

        var 徽章:NSNumber? { 设置 }

        说明 申请号码 应用程序的图标。

        使用此属性指定要申请的号码 通知到达时应用程序的图标。如果您的应用不是 授权显示基于徽章的通知,此属性是 已忽略。

        指定数字 0 以移除当前徽章(如果存在)。 指定一个大于 0 的数字以显示带有该数字的徽章。 指定 nil 以保持当前徽章不变。

        SDK iOS 10.0+、tvOS 10.0+,watchOS 3.0+

        即使应用没有运行,当添加通知时,徽章也会自动增加。您可以在应用程序中的任意位置清除徽章编号:

        UIApplication.shared.applicationIconBadgeNumber = 0
        

        【讨论】:

        • 您能解释一下在哪里设置此代码 UIApplication.shared.applicationIconBadgeNumber = 0 以在打开此类通知时清除徽章计数。如果可能,请添加清晰且递增的徽章计数代码。谢谢
        【解决方案8】:

        作为 Bionicle 解决方案的替代方案,可以使用 NSSortDescriptor 来处理基于 fireDate 字段的排序。同样,此解决方案提供了 Whasssaaahhh 原始答案的所有好处,但也意味着它可以处理以非时间顺序添加的通知,例如在 30 秒内添加通知,然后在 20 秒内添加通知。添加本地通知以及返回应用程序时,我会调用以下函数。

        // When we add/remove local notifications, if we call this function, it will ensure each notification
        // will have an ascending badge number specified.
        - (void)renumberBadgesOfPendingNotifications
        {
            // Clear the badge on the icon
            [[UIApplication sharedApplication] setApplicationIconBadgeNumber:0];
        
            // First get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
            NSMutableArray * pendingNotifications = [[[UIApplication sharedApplication] scheduledLocalNotifications] mutableCopy];
        
            // Sorted by fire date.
            NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc] initWithKey:@"fireDate" ascending:TRUE];
            [pendingNotifications sortUsingDescriptors:[NSArray arrayWithObject:sortDescriptor]];
            [sortDescriptor release];
        
            // if there are any pending notifications -> adjust their badge number
            if (pendingNotifications.count != 0)
            {
                // clear all pending notifications
                [[UIApplication sharedApplication] cancelAllLocalNotifications];
        
                // the for loop will 'restore' the pending notifications, but with corrected badge numbers
                // note : a more advanced method could 'sort' the notifications first !!!
                NSUInteger badgeNbr = 1;
        
                for (UILocalNotification *notification in pendingNotifications)
                {
                    // modify the badgeNumber
                    notification.applicationIconBadgeNumber = badgeNbr++;
        
                    // schedule 'again'
                    [[UIApplication sharedApplication] scheduleLocalNotification:notification];
                }
            }
        
            // Release our copy.
            [pendingNotifications release];
        }
        

        【讨论】:

          【解决方案9】:

          根据上述 Wassaahbbs 和 Bionicles 的回答,对于 Swift 3.0,这似乎适用于 重复本地通知。我可以设置 4 个本地通知,每个通知都可以独立打开和关闭。

          在 AppDelegate applicationDidBecomeActive 中调用 renumberBadgesOfPendingNotifications 函数,因此如果用户在收到通知后打开应用程序,则会更新徽章。并且还在 settingsVC 中,其中 setNotification 函数首先设置通知,以防用户打开或关闭通知,从而需要更新徽章。

          徽章在 applicationDidBecomeActive 中设置为 0,UIApplication.shared.applicationIconBadgeNumber = 0。

          func renumberBadgesOfPendingNotifications() {
              // first get a copy of all pending notifications (unfortunately you cannot 'modify' a pending notification)
              let pendingNotifications = UIApplication.shared.scheduledLocalNotifications
              print("AppDel there are \(pendingNotifications?.count) pending notifs now")
          
              // if there are any pending notifications -> adjust their badge number
              if var pendings = pendingNotifications, pendings.count > 0 {
          
                  // sort into earlier and later pendings
                  var notifications = pendings
                  var earlierNotifs = [UILocalNotification]()
                  var laterNotifs = [UILocalNotification]()
          
                  for pending in pendings {
          
                      // Skip notification scheduled earlier than current date time
                      if pending.fireDate?.compare(NSDate() as Date) == ComparisonResult.orderedAscending {
                          // and use this if it has NO REPEAT INTERVAL && notif.repeatInterval.rawValue == NSCalendar.Unit.init(rawValue:0).rawValue {
          
                          // track earlier and later pendings
                          earlierNotifs.append(pending)
                      }
                      else {
                          laterNotifs.append(pending)
                      }
                  }
          
                  print("AppDel there are \(earlierNotifs.count) earlier notifications")
                  print("AppDel there are \(laterNotifs.count) later notifications")
          
                  // change the badge on the notifications due later
                  pendings = laterNotifs
          
                  // sorted by fireDate.
                  notifications = pendings.sorted(by: { p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .orderedAscending })
          
                  // clear all pending notifications. i.e the laterNotifs
                  for pending in pendings {
                      UIApplication.shared.cancelLocalNotification(pending)
                  }
          
                  // the for loop will 'restore' the pending notifications, but with corrected badge numbers
                  var laterBadgeNumber = 0
                  for n in notifications {
          
                      // modify the badgeNumber
                      laterBadgeNumber += 1
                      n.applicationIconBadgeNumber = laterBadgeNumber
          
                      // schedule 'again'
                      UIApplication.shared.scheduleLocalNotification(n)
                      print("AppDel later notif scheduled with badgenumber \(n.applicationIconBadgeNumber)")
                  }
          
                  // change the badge on the notifications due earlier
                  pendings = earlierNotifs
          
                  // sorted by fireDate.
                  notifications = pendings.sorted(by: { p1, p2 in p1.fireDate!.compare(p2.fireDate!) == .orderedAscending })
          
                  // clear all pending notifications. i.e the laterNotifs
                  for pending in pendings {
                      UIApplication.shared.cancelLocalNotification(pending)
                  }
          
                  // the for loop will 'restore' the pending notifications, but with corrected badge numbers
                  var earlierBadgeNumber = laterBadgeNumber
                  for n in notifications {
          
                      // modify the badgeNumber
                      earlierBadgeNumber += 1
                      n.applicationIconBadgeNumber = earlierBadgeNumber
          
                      // schedule 'again'
                      UIApplication.shared.scheduleLocalNotification(n)
                      print("AppDel earlier notif scheduled with badgenumber \(n.applicationIconBadgeNumber)")
                  }
              }
          }
          

          【讨论】:

            【解决方案10】:

            基于以上 Wassaahbbs 和 Bionicles 的答案。 Swift 4.0,适用于所有 iOS 版本。在func applicationDidBecomeActive(_ application: UIApplication)中调用这个函数。

            func renumberBadgesOfPendingNotifications() {
                if #available(iOS 10.0, *) {
                    UNUserNotificationCenter.current().getPendingNotificationRequests { pendingNotificationRequests in
                        if pendingNotificationRequests.count > 0 {
                            let notificationRequests = pendingNotificationRequests
                                .filter { $0.trigger is UNCalendarNotificationTrigger }
                                .sorted(by: { (r1, r2) -> Bool in
                                    let r1Trigger = r1.trigger as! UNCalendarNotificationTrigger
                                    let r2Trigger = r2.trigger as! UNCalendarNotificationTrigger
                                    let r1Date = r1Trigger.nextTriggerDate()!
                                    let r2Date = r2Trigger.nextTriggerDate()!
            
                                    return r1Date.compare(r2Date) == .orderedAscending
                                })
            
                            let identifiers = notificationRequests.map { $0.identifier }
                            UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: identifiers)
            
                            notificationRequests.enumerated().forEach { (index, request) in
                                if let trigger = request.trigger {
                                    let content = UNMutableNotificationContent()
                                    content.body = request.content.body
                                    content.sound = .default()
                                    content.badge = (index + 1) as NSNumber
            
                                    let request = UNNotificationRequest(identifier: request.identifier, content: content, trigger: trigger)
                                    UNUserNotificationCenter.current().add(request)
                                }
                            }
                        }
                    }
                } else if let pendingNotifications = UIApplication.shared.scheduledLocalNotifications, pendingNotifications.count > 0 {
                    let notifications = pendingNotifications
                        .filter { $0.fireDate != nil }
                        .sorted(by: { n1, n2 in n1.fireDate!.compare(n2.fireDate!) == .orderedAscending })
            
                    notifications.forEach { UIApplication.shared.cancelLocalNotification($0) }
                    notifications.enumerated().forEach { (index, notification) in
                        notification.applicationIconBadgeNumber = index + 1
                        UIApplication.shared.scheduleLocalNotification(notification)
                    }
                }
            }
            

            【讨论】:

              【解决方案11】:

              这是一个棘手的问题。由于 iOS 不会为您跟踪本地通知的徽章编号,因此您可以自行维护每个通知的编号并及时更新。

              为了更复杂,nextTriggerDate 类中提供的函数UNTimeIntervalNotificationTrigger 不能正常工作。因此,如果您依靠它来订购未决通知和发送通知,将会出现混乱。

              我设法找到的一个实用且简化的解决方案是首先删除所有通知,然后在您需要发送新通知时根据您的逻辑重新发送它们。这样可以保证他们的徽章编号都是正确的。

              总之,您至少应该在以下条目中执行此类操作:

              1. userNotificationCenter(_:didReceive:withCompletionHandler:)
              2. userNotificationCenter(_:willPresent:withCompletionHandler:)
              3. 您发送新通知的位置。
              4. 您将应用的徽章编号设置为零。

              【讨论】:

                猜你喜欢
                • 2012-06-24
                • 1970-01-01
                • 1970-01-01
                • 1970-01-01
                • 2011-07-19
                • 1970-01-01
                • 2022-01-21
                • 1970-01-01
                • 1970-01-01
                相关资源
                最近更新 更多