时间控制组件-TimerTickerManager

最新推荐文章于 2023-06-11 15:58:17 发布
最新推荐文章于 2023-06-11 15:58:17 发布
阅读量795 收藏
点赞数
分类专栏： iOS 文章标签： ios github
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/game3108/article/details/51170065
版权

简书地址：http://www.jianshu.com/p/8351afd12e3c

前言

计时器是经常使用的一个组件，比如说登陆操作的时候，点击获取验证码的按钮的时候，需要有一个30秒的倒计时，防止用户误点或者多次点击。
因此写了个时间控制的组件，用来控制倒计时等操作，具体代码放在了github上，

正文

在iOS里，定时操作主要有两个办法
* NSTimer的scheduledTimerWithTimeInterval方法，设置时间间隔，执行相应的函数。
使用NSTimer的话，要注意在该线程上是否有runloop，以及添加的Runloop Mode，不然容易出现滑动scrollview的时候，倒计时卡住的情况。

  • GCD的dispatch source。使用dispatch_source_set_timer来设置定时器。
void
dispatch_source_set_timer(dispatch_source_t source,
 dispatch_time_t start,
 uint64_t interval,
 uint64_t leeway);

方法的四个参数，分别是：
- source：事件源
- start: 开始时间
- interval:间隔时间
- leeway:精度

配合上

void
dispatch_source_set_event_handler(dispatch_source_t source,
dispatch_block_t handler);

设置事件源的block回调，就可以完成定时器的设置。

代码讲解

TimerTicker 时间操作类
//
//  TimerTicker.h
//  TimerTickerManager
//
//  Created by game3108 on 16/4/15.
//  Copyright © 2016年 game3108. All rights reserved.
//

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

typedef NS_ENUM(NSInteger , TimerTickerType){
    TypeStop = 0,
    TypeOnFire = 1,
    TypePause =2,
    TypeNone = 3
};

@protocol TimerTickerDelegate <NSObject>
- (void) onTimerStop;
- (void) onTimerTicker:(CGFloat) ticker;
@end

@interface TimerTicker : NSObject
@property (nonatomic, assign) CGFloat endNumber;
@property (nonatomic, assign) CGFloat startNumber;
@property (nonatomic, assign) CGFloat tickerGap;
@property (nonatomic, assign) BOOL needStop;
@property (nonatomic, weak) id<TimerTickerDelegate> delegate;
- (dispatch_source_t)startTimeTicker;
- (void)stopTimerTicker;
- (void)pauseTimerTicker;
- (void)resumeTimerTicker;
- (TimerTickerType)getTimerTickerType;
@end
//
//  TimerTicker.m
//  TimerTickerManager
//
//  Created by game3108 on 16/4/15.
//  Copyright © 2016年 game3108. All rights reserved.
//

#import "TimerTicker.h"

@interface TimerTicker(){
    dispatch_source_t _timer;
    BOOL _onFire;
}

@end

@implementation TimerTicker

- (instancetype)init{
    self = [super init];
    if ( self ){
        _tickerGap = 1;
        _startNumber = 0;
        _endNumber = 0;
        _needStop = NO;
    }
    return self;
}

#pragma mark TimerTicker function
- (dispatch_source_t)startTimeTicker{
    if ( _timer ){
        if ( !_onFire )
            dispatch_resume(_timer);
        dispatch_source_cancel(_timer);
        _timer = nil;
    }
    CGFloat endNumber   = _endNumber;
    CGFloat startNumber = _startNumber;
    BOOL needStop       = _needStop;
    CGFloat tickerGap   = _tickerGap;
    BOOL timerTickerUp  = YES;
    if ( _tickerGap < 0 ){
        tickerGap = - _tickerGap;
        timerTickerUp = NO;
    }

    if ( (endNumber == startNumber) && needStop ){
        [_delegate onTimerStop];
        return nil;
    }
    if ( !_needStop ){
        endNumber = startNumber;
    }
    __block CGFloat timerTicker = (startNumber - endNumber) / tickerGap;
    if ( timerTicker > 0 ){
        timerTickerUp = NO;
    }
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    dispatch_source_set_timer(_timer, dispatch_walltime(NULL, 0), tickerGap*NSEC_PER_SEC, tickerGap*NSEC_PER_SEC*0.1);

    __weak TimerTicker *weakSelf = self;
    dispatch_source_set_event_handler(_timer, ^{
        BOOL judgeStop = [weakSelf judgeStop:timerTicker andTimeTickerUp:timerTickerUp andNeedStop:needStop];
        if(judgeStop) {
            [weakSelf onTimerStop];
        }else{
            [weakSelf onTimertTicker:timerTicker andTickerGap:tickerGap andEndNumber:endNumber];
            if ( timerTickerUp )
                timerTicker++;
            else
                timerTicker--;
            //NSLog(@"!!!!!!!!!%f",timerTicker);
        }
    });
    dispatch_resume(_timer);
    _onFire = YES;
    return _timer;
}

- (void)stopTimerTicker{
    if ( _timer ){
        if ( !_onFire )
            dispatch_resume(_timer);
        dispatch_source_cancel(_timer);
        _timer = nil;
    }
}

- (void)pauseTimerTicker{
    if ( _timer && _onFire ){
        dispatch_suspend(_timer);
        _onFire = NO;
    }
}

- (void)resumeTimerTicker{
    if ( _timer && !_onFire ){
        dispatch_resume(_timer);
        _onFire = YES;
    }
}

- (TimerTickerType)getTimerTickerType{
    if ( !_timer )
        return TypeStop;
    else if ( _onFire )
        return TypeOnFire;
    else
        return TypePause;
}

#pragma mark startTimeTicker related function

- (BOOL) judgeStop:(CGFloat)timerTicker andTimeTickerUp:(BOOL)ifUp andNeedStop:(BOOL)needStop{
    BOOL state1 = needStop && ifUp && timerTicker >=0;
    BOOL state2 = needStop && !ifUp && timerTicker <= 0;
    return state1 || state2;
}

- (void)onTimerStop{
    dispatch_source_cancel(_timer);
    dispatch_sync(dispatch_get_main_queue(), ^{
        [_delegate onTimerStop];
    });
}

- (void)onTimertTicker:(CGFloat)timerTicker andTickerGap:(CGFloat)tickerGap andEndNumber:(CGFloat)endNumber{
    dispatch_sync(dispatch_get_main_queue(), ^{
        [_delegate onTimerTicker:timerTicker*tickerGap+endNumber];
    });
}

#pragma mark dealloc

-(void)dealloc{
    [self stopTimerTicker];
    NSLog(@"timer ticker dealloc");
}

@end

TimerTicker类是直接进行时间控制的操作类。
- startNumber:开始数字
- endNumber:结束数字
- tickerGap:时间间隔精度
- needStop:代表是否停止，设置为YES，则endNumber会无效
- delegate:回调
函数调用包括：
- startTimeTicker：开始计时
- stopTimerTicker：结束计时
- pauseTimerTicker： 暂停计时
- resumeTimerTicker：重新计时
- getTimerTickerType: 获取当前类型

startTimeTicker是主要的开始方法。
具体逻辑不是那么复杂，应该可以看得懂，但写的时候碰到很多坑，具体的坑会在后面写出来。

TimerTickerManager控制类

TimerTickerManager主要提供给外部API，简化使用。

//
//  TimerTickerManager.h
//  TimerTickerManager
//
//  Created by game3108 on 16/4/16.
//  Copyright © 2016年 game3108. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "TimerTicker.h"

@interface TimerTickerManager : NSObject
+ (instancetype) sharedInstrance;
- (void)startTimerTicker:(id<TimerTickerDelegate>)delegate
                 withKey:(NSString *)key
         withStartNumber:(CGFloat)startNumber
           withEndNumber:(CGFloat)endNumber
           withTickerGap:(CGFloat)tickerGap;
- (void)startTimerTicker:(id<TimerTickerDelegate>)delegate
                 withKey:(NSString *)key
         withStartNumber:(CGFloat)startNumber
           withTickerGap:(CGFloat)tickerGap;
- (void)startTimerTicker:(id<TimerTickerDelegate>)delegate
                 withKey:(NSString *)key
           withTickerGap:(CGFloat)tickerGap;

- (void) setTimerTickerDelegate:(id<TimerTickerDelegate>) delegate
                        withKey:(NSString *)key;
- (void) removeTimerTickerDelegate:(id<TimerTickerDelegate>) delegate
                           withKey:(NSString *)key;
- (void) removeTimerTickerWithKey:(NSString *)key;
- (void) setTimerTickerStop:(NSString *)key;
- (void) setTimerTickerPause:(NSString *)key;
- (void) setTimerTickerResume:(NSString *)key;
- (BOOL) judgeExistTimerTicker:(NSString *)key;
- (TimerTickerType)getTimerTickerType:(NSString *)key;
@end
//
//  TimerTickerManager.m
//  TimerTickerManager
//
//  Created by game3108 on 16/4/16.
//  Copyright © 2016年 game3108. All rights reserved.
//

#import "TimerTickerManager.h"

@interface TimerTickerManager(){
    NSMutableDictionary *_timerTickerDic;
}

@end

static TimerTickerManager *instrance = nil;

@implementation TimerTickerManager

+ (void)initialize{
    instrance = [[TimerTickerManager alloc]init];
    instrance->_timerTickerDic = [[NSMutableDictionary alloc]init];
}

+ (instancetype) sharedInstrance{
    return instrance;
}

- (void)startTimerTicker:(id<TimerTickerDelegate>)delegate
                 withKey:(NSString *)key
         withStartNumber:(CGFloat)startNumber
           withEndNumber:(CGFloat)endNumber
           withTickerGap:(CGFloat)tickerGap{
    [self startTimerTicker:delegate
                   withKey:key
           withStartNumber:startNumber
             withEndNumber:endNumber
             withTickerGap:tickerGap
              withNeedStop:YES];
}
- (void)startTimerTicker:(id<TimerTickerDelegate>)delegate
                 withKey:(NSString *)key
         withStartNumber:(CGFloat)startNumber
           withTickerGap:(CGFloat)tickerGap{
    [self startTimerTicker:delegate
                   withKey:key
           withStartNumber:startNumber
             withEndNumber:startNumber
             withTickerGap:tickerGap
              withNeedStop:NO];

}
- (void)startTimerTicker:(id<TimerTickerDelegate>)delegate
                 withKey:(NSString *)key
           withTickerGap:(CGFloat)tickerGap{
    [self startTimerTicker:delegate
                   withKey:key
           withStartNumber:0
             withEndNumber:0
             withTickerGap:tickerGap
              withNeedStop:NO];
}

- (void)startTimerTicker:(id<TimerTickerDelegate>)delegate
                 withKey:(NSString *)key
         withStartNumber:(CGFloat)startNumber
           withEndNumber:(CGFloat)endNumber
           withTickerGap:(CGFloat)tickerGap
            withNeedStop:(BOOL)needStop{
    TimerTicker *objcTimerTicker = [_timerTickerDic objectForKey:key];
    if ( objcTimerTicker ){
        objcTimerTicker.tickerGap = tickerGap;
        objcTimerTicker.startNumber = startNumber;
        objcTimerTicker.endNumber = endNumber;
        objcTimerTicker.needStop = needStop;
        objcTimerTicker.delegate = delegate;
        [objcTimerTicker startTimeTicker];
        NSLog(@"timeticker reuse ticker");
    }else{
        TimerTicker *timerTicker = [[TimerTicker alloc]init];
        timerTicker.tickerGap = tickerGap;
        timerTicker.startNumber = startNumber;
        timerTicker.endNumber = endNumber;
        timerTicker.needStop = needStop;
        timerTicker.delegate = delegate;
        [_timerTickerDic setObject:timerTicker forKey:key];
        [timerTicker startTimeTicker];
        NSLog(@"timeticker new ticker");
    }
}

- (void) setTimerTickerDelegate:(id<TimerTickerDelegate>) delegate
                        withKey:(NSString *)key{
    TimerTicker *objcTimerTicker = [_timerTickerDic objectForKey:key];
    if ( objcTimerTicker != nil )
        objcTimerTicker.delegate = delegate;
}

- (void) removeTimerTickerDelegate:(id<TimerTickerDelegate>) delegate
                           withKey:(NSString *)key{
    TimerTicker *objcTimerTicker = [_timerTickerDic objectForKey:key];
    if ( objcTimerTicker != nil )
        objcTimerTicker.delegate = nil;
}

- (void) removeTimerTickerWithKey:(NSString *)key{
    [_timerTickerDic removeObjectForKey:key];
}

- (void) setTimerTickerStop:(NSString *)key{
    TimerTicker *objcTimerTicker = [_timerTickerDic objectForKey:key];
    if ( objcTimerTicker != nil )
        [objcTimerTicker stopTimerTicker];
}

- (void) setTimerTickerPause:(NSString *)key{
    TimerTicker *objcTimerTicker = [_timerTickerDic objectForKey:key];
    if ( objcTimerTicker != nil )
        [objcTimerTicker pauseTimerTicker];
}

- (void) setTimerTickerResume:(NSString *)key{
    TimerTicker *objcTimerTicker = [_timerTickerDic objectForKey:key];
    if ( objcTimerTicker != nil )
        [objcTimerTicker resumeTimerTicker];
}

- (BOOL) judgeExistTimerTicker:(NSString *)key{
    return [[_timerTickerDic allKeys] containsObject:key];;
}
- (TimerTickerType)getTimerTickerType:(NSString *)key{
    TimerTicker *objcTimerTicker = [_timerTickerDic objectForKey:key];
    if ( objcTimerTicker != nil )
        return [objcTimerTicker getTimerTickerType];
    else
        return TypeNone;
}

@end

TimerTickerManger使用注意：

1.设置时间方式
默认的startNumber开始时间为0，tickerGap时间间隔为1，使用没有endNumber的调用，就不会停止，tickerGap大于0为增加，小于0为减少。
但如果使用有endNumber的方法，startNumber小于endNumber则一定是倒数，大于则一定是正数，与tickerGap正负无关。
tickerGap为0则没有效果。
如

[[TimerTickerManager sharedInstrance]startTimerTicker:self
                                                  withKey:@"key1"
                                          withStartNumber:30
                                            withEndNumber:20
                                            withTickerGap:0.5];

即从30倒计时到20，间隔为0.5，不停触发delegate回调

2.为什么会有setTimerTickerStop还会有removeTimerTickerDelegate方法？
比如注册界面按获取验证码倒计时30秒操作，如果用户触发完30秒倒计时，退出注册界面，这个时候倒计时应该继续进行，如果用户重新打开注册页面，要从上次的倒计时继续进行，所以会有setTimerTickerDelegate,removeTimerTickerDelegate,getTimerTickerType。

一些坑

1.关于循环应用问题
dispatch_source_set_event_handler回调是一个block，所以很容易会出现循环引用问题。

__weak TimerTicker *weakSelf = self;

这个weak也主要为了防止循环引用。但写的一开始的版本还是有循环引用问题，后来检查了才发现，原来是在block内引用了实例变量，比如说
_startNumber等。很多时候也许self.startNumber的形式更容易让人意识到循环引用问题，但用实例变量_startNumber的形式也会有循环引用，block持有self。
2.关于dispatch_suspend与dispatch_resume
首先dispatch_suspend与dispatch_resume在对主线程没有效果。其次，这两个方法对应，拿Apple的注释来说

Calls to dispatch_suspend() must be balanced with calls
to dispatch_resume().

你调用了suspend几次，你想resume的话，就必须要remuse几次，才能继续运行。但remuse的状态下，如果再进行一次resume就会crash，所以要注册一个onFire的状态进行记录，防止多次suspend和resume。

除此以外，在suspend的状态下，如果你设置_timer = nil就会crash，所以必须先resume，再cancel再设为nil，如下：

- (void)stopTimerTicker{
    if ( _timer ){
        if ( !_onFire )
            dispatch_resume(_timer);
        dispatch_source_cancel(_timer);
        _timer = nil;
    }
}
参考资料

1.GCD介绍（三）: Dispatch Sources](http://www.cnblogs.com/zhw511006/archive/2012/04/06/2434714.html)

game3108
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vue时间组件-demo.zip
11-25
时间组件，可以通过点击，鼠标滑动选择实时间段
vue组件-自定义滚动条
06-30
vue组件-自定义滚动条
go语言中Timer和Ticker两种计时器
m0_53328239的博客
05-04 663
go语言中有Timer和Ticker这样的两种计时器，两种计时器分别实现了不同的计时功能。Timer是单次时间事件，指在指定的单次时间过后触发，然后向自己channel中发送当时时间，此后Timer不再计时。Ticker是多次时间事件，指每隔一段事件都触发一次，并向自己channel发送当前时间。类似于javascript中的setTimeout()和setInterval()两种计时器。
Go并发编程— —Timer、Ticker、WaitGroup及其他常用模型
最新发布
weixin_45565886的博客
06-11 1221
Go并发编程— —Timer、Ticker、WaitGroup及其他常用模型
定时器Timer和Ticker
weixin_38299404的博客
08-03 839
Timer Timer是一个定时器，代表未来的一个单一事件，通过Timer本身提供的管道将事件传递出去，言外之意是只执行一次。 Timer的数据结构如下： type Timer struct { C <-chan Time r runtimeTimer } package main import ( "fmt" "time" ) func main() { // 1.timer基本使用 timer1 := time.NewTimer(2 * time.Second) t1 := t
Go (Golang) 语言-Golang 定时器Timer和Ticker、time.AfterFunc、time.NewTicker()实例
西京刀客
06-28 9760
Golang 定时器包括：一次性定时器（Timer）和周期性定时器(Ticker)。编程中经常会通过timer和ticker。 Golang time.Timer and time.Ticker 参考URL: https://www.jianshu.com/p/2b4686b8de4a time.Timer 首先我们看Timer的结构定义： type Timer struct { C <-chan Time r runtimeTimer } 其中有一个C的只读chann
TimerTask is scheduled already 解决方法
lishouyi710的专栏
12-15 4262
使用Timer时出现错误java.lang.IllegalStateException: TimerTask is scheduled already 代码： private TimerTask mTimerTask = new TimerTask() { @Override public void run() { // TODO Auto-generated metho
易语言选择当天时间组件 - 组合框拼接源码
06-02
@浅浅`。Tags：组合框拼接。
Unity 日历组件-日期选择器2D
03-09
Unity 日期选择器组件 ！结构简单，层级明朗，便于理解。可更改ui和尺寸用于不同场合。~~~总结归纳，便于使用。避免重复造轮子~~~
ASP控制Serv-U组件
04-28
一个用于ASP在线开通管理Serv-U的组件，可在线添加修改FTP用户，可控制空间配额和操作权限，直接修改Serv-U ini文件
TimerTicker计时器
02-24
需要XP下可能需要安装.net Framework3.5，软件会自动在线下载 功能介绍： 1.全屏模式 PPT模式两种计时模式 2.支持正计时，倒计时 3.可以自定义声音，背景及主题名称 4.可支持自由拖动小窗显示位置 5.支持两次计时提醒 6.时间到后锁定屏幕 PS：README.txt里面的授权注册信息错了。新的用户名，密码均为 usst
react-reactdraggableReact可拖拽组件
08-15
react-draggable - React可拖拽组件
微信小程序自定义组件--日历组件
06-05
这是自己编写的一个轻量级的微信小程序组件，将该组件解压到你的组件文件夹下，即可使用。该组件可以标记日期，自行更改标记图标即可，可折叠展开，可左右滑动切换月份
vue签名组件-移动
06-13
此组件为单独组件，通过components引入即可使用，根据项目需求自行配置编写样式
微信小城程序组件---折叠面板
12-20
微信小程序自定义组件，折叠面板组件，数据格式为[{foldTitle: "面板标题",foldState:"默面板打开还是隐藏",foldContent:"面板文字"}]
微信小程序组件---授权信息弹窗
12-20
在开发小程序的时候需要获取用户信息权限和用户手机号码，该组件使用弹窗的方式让用户点击确认授权：使用showUserInfoPopup();显示用户信息授权弹窗，使用showPhoneInfoPopup();显示用户电话号码授权弹窗
bootstrap-datetimepicker时间组件
08-19
bootstrap样式控制的datetimepicker时间组件，分为bootstrap v2、bootstrap v3、bootstrap v4三个版本
仿钉钉的会议时间轴组件
07-27
仿钉钉的会议时间轴组件包括 过期时间 被选时间
vuecutetimeline一个可爱的Vuejs时间轴组件
08-09
vue-cute-timeline：一个可爱的Vue.js时间轴组件
如何控制el-dialog组件大小
06-07
在`el-dialog`组件中，可以使用`width`属性和`height`属性来控制对话框的大小，其中`width`属性用于控制对话框的宽度，`height`属性用于控制对话框的高度。这两个属性可以设置为像素值、百分比值或字符串形式的值，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值