add getProxyPusherInfo and getProxyInfo restful api

src/Player/PlayerProxy.cpp

@@ -30,6 +30,10 @@ PlayerProxy::PlayerProxy(const string &vhost, const string &app, const string &s
     _app = app;
     _stream_id = stream_id;
     _retry_count = retry_count;
+    
+    _live_secs = 0;
+    _live_status = 1;
+    _repull_count = 0;
     _on_close = [](const SockException &) {};
     (*this)[Client::kWaitTrackReady] = false;
 }
@@ -58,10 +62,14 @@ void PlayerProxy::play(const string &strUrlTmp) {
 
         if (!err) {
             // 取消定时器,避免hls拉流索引文件因为网络波动失败重连成功后出现循环重试的情况
-           strongSelf->_timer.reset();
+            strongSelf->_timer.reset();
+            strongSelf->_live_ticker.resetTime();
+            strongSelf->_live_status = 0;
             // 播放成功
             *piFailedCnt = 0;//连续播放失败次数清0
             strongSelf->onPlaySuccess();
+
+            InfoL << "play " << strUrlTmp << " success";
         } else if (*piFailedCnt < strongSelf->_retry_count || strongSelf->_retry_count < 0) {
             // 播放失败，延时重试播放
             strongSelf->rePlay(strUrlTmp, (*piFailedCnt)++);
@@ -92,8 +100,17 @@ void PlayerProxy::play(const string &strUrlTmp) {
                 strongSelf->_muxer->resetTracks();
             }
         }
+
+        if(*piFailedCnt == 0){
+            // 第一次重拉更新时长
+            strongSelf->_live_secs += strongSelf->_live_ticker.elapsedTime()/1000;
+            strongSelf->_live_ticker.resetTime();
+            TraceL<<" live secs "<<strongSelf->_live_secs;
+        }
+
         //播放异常中断，延时重试播放
         if (*piFailedCnt < strongSelf->_retry_count || strongSelf->_retry_count < 0) {
+            strongSelf->_repull_count++;
             strongSelf->rePlay(strUrlTmp, (*piFailedCnt)++);
         } else {
             //达到了最大重试次数，回调关闭
@@ -241,4 +258,19 @@ void PlayerProxy::onPlaySuccess() {
     }
 }
 
+int PlayerProxy::getStatus() {
+    return _live_status.load();
+}
+uint64_t PlayerProxy::getLiveSecs() {
+    if(_live_status == 0){
+        return _live_secs + _live_ticker.elapsedTime()/1000;
+    }else{
+        return _live_secs;
+    }
+}
+
+uint64_t PlayerProxy::getRePullCount(){
+    return _repull_count;
+}
+
 } /* namespace mediakit */

src/Player/PlayerProxy.h

@@ -52,6 +52,11 @@ public:
      */
     int totalReaderCount() ;
 
+
+    int getStatus();
+    uint64_t getLiveSecs();
+    uint64_t getRePullCount();
+
 private:
     //MediaSourceEvent override
     bool close(MediaSource &sender) override;
@@ -76,6 +81,13 @@ private:
     std::function<void(const toolkit::SockException &ex)> _on_close;
     std::function<void(const toolkit::SockException &ex)> _on_play;
     MultiMediaSourceMuxer::Ptr _muxer;
+
+    toolkit::Ticker _live_ticker;
+    //0 表示正常 1 表示正在尝试拉流
+    std::atomic<int> _live_status; 
+    std::atomic<uint64_t> _live_secs;
+
+    std::atomic<uint64_t> _repull_count;
 };
 
 } /* namespace mediakit */

src/Pusher/PusherProxy.cpp

@@ -20,6 +20,9 @@ PusherProxy::PusherProxy(const MediaSource::Ptr &src, int retry_count, const Eve
     _retry_count = retry_count;
     _on_close = [](const SockException &) {};
     _weak_src = src;
+    _live_secs = 0;
+    _live_status = 1;
+    _republish_count = 0;
 }
 
 PusherProxy::~PusherProxy() {
@@ -52,10 +55,14 @@ void PusherProxy::publish(const string &dst_url) {
         auto src = strong_self->_weak_src.lock();
         if (!err) {
             // 推流成功
+            strong_self->_live_ticker.resetTime();
+            strong_self->_live_status = 0;
             *failed_cnt = 0;
             InfoL << "Publish " << dst_url << " success";
         } else if (src && (*failed_cnt < strong_self->_retry_count || strong_self->_retry_count < 0)) {
             // 推流失败，延时重试推送
+            strong_self->_republish_count++;
+            strong_self->_live_status = 1;
             strong_self->rePublish(dst_url, (*failed_cnt)++);
         } else {
             //如果媒体源已经注销, 或达到了最大重试次数，回调关闭
@@ -69,9 +76,17 @@ void PusherProxy::publish(const string &dst_url) {
             return;
         }
 
+        if(*failed_cnt == 0){
+            // 第一次重推更新时长
+            strong_self->_live_secs += strong_self->_live_ticker.elapsedTime()/1000;
+            strong_self->_live_ticker.resetTime();
+            TraceL<<" live secs "<<strong_self->_live_secs;
+        }
+
         auto src = strong_self->_weak_src.lock();
         //推流异常中断，延时重试播放
         if (src && (*failed_cnt < strong_self->_retry_count || strong_self->_retry_count < 0)) {
+            strong_self->_republish_count++;
             strong_self->rePublish(dst_url, (*failed_cnt)++);
         } else {
             //如果媒体源已经注销, 或达到了最大重试次数，回调关闭
@@ -97,4 +112,19 @@ void PusherProxy::rePublish(const string &dst_url, int failed_cnt) {
     }, getPoller());
 }
 
+int PusherProxy::getStatus() {
+    return _live_status.load();
+}
+uint64_t PusherProxy::getLiveSecs() {
+    if(_live_status == 0){
+        return _live_secs + _live_ticker.elapsedTime()/1000;
+    }else{
+        return _live_secs;
+    }
+}
+
+uint64_t PusherProxy::getRePublishCount(){
+    return _republish_count;
+}
+
 } /* namespace mediakit */

src/Pusher/PusherProxy.h

@@ -43,6 +43,10 @@ public:
      */
     void publish(const std::string& dstUrl) override;
 
+    int getStatus();
+    uint64_t getLiveSecs();
+    uint64_t getRePublishCount();
+
 private:
     // 重推逻辑函数
     void rePublish(const std::string &dstUrl, int iFailedCnt);
@@ -50,6 +54,11 @@ private:
 private:
     int _retry_count;
     toolkit::Timer::Ptr _timer;
+    toolkit::Ticker _live_ticker;
+    //0 表示正常 1 表示正在尝试推流
+    std::atomic<int> _live_status; 
+    std::atomic<uint64_t> _live_secs;
+    std::atomic<uint64_t> _republish_count;
     std::weak_ptr<MediaSource> _weak_src;
     std::function<void(const toolkit::SockException &ex)> _on_close;
     std::function<void(const toolkit::SockException &ex)> _on_publish;