Merge pull request #1 from 2580258036Aa/golem/2.8.0

DynamicKey/AgoraDynamicKey/cpp/sample/RtcTokenBuilder2Sample.cpp

@@ -24,12 +24,12 @@ int main(int argc, char const *argv[]) {
   std::string result;
   result = RtcTokenBuilder2::BuildTokenWithUid(
       app_id, app_certificate, channel_name, uid, UserRole::kRolePublisher,
-      privilege_expiration_in_seconds);
+      token_expiration_in_seconds, privilege_expiration_in_seconds);
   std::cout << "Token With Int Uid:" << result << std::endl;
 
   result = RtcTokenBuilder2::BuildTokenWithUserAccount(
       app_id, app_certificate, channel_name, account, UserRole::kRolePublisher,
-      privilege_expiration_in_seconds);
+      token_expiration_in_seconds, privilege_expiration_in_seconds);
   std::cout << "Token With UserAccount:" << result << std::endl;
 
   result = RtcTokenBuilder2::BuildTokenWithUid(

DynamicKey/AgoraDynamicKey/cpp/src/AccessToken2.h

@@ -111,134 +111,6 @@ class ServiceRtc : public Service {
   ServiceRtc &operator=(ServiceRtc &&) = default;
 };
 
-class ServiceRtm : public Service {
- public:
-  enum {
-    kServiceType = 2,
-
-    kPrivilegeLogin = 1,
-  };
-
- public:
-  ServiceRtm(const std::string &user_id = "")
-      : Service(kServiceType), user_id_(user_id) {}
-
-  virtual std::string PackService() override { return Pack(this); }
-
-  virtual void UnpackService(Unpacker *unpacker) override { *unpacker >> this; }
-
-  virtual std::unique_ptr<Service> Clone() const override {
-    return std::unique_ptr<Service>(new ServiceRtm(*this));
-  }
-
-  friend agora::tools::Packer &operator<<(agora::tools::Packer &p,
-                                          const ServiceRtm *x) {
-    p << dynamic_cast<const Service *>(x) << x->user_id_;
-    return p;
-  }
-
-  friend agora::tools::Unpacker &operator>>(agora::tools::Unpacker &p,
-                                            ServiceRtm *x) {
-    p >> dynamic_cast<Service *>(x) >> x->user_id_;
-    return p;
-  }
-
- public:
-  std::string user_id_;
-
- protected:
-  ServiceRtm(const ServiceRtm &) = default;
-  ServiceRtm(ServiceRtm &&) = default;
-  ServiceRtm &operator=(const ServiceRtm &) = default;
-  ServiceRtm &operator=(ServiceRtm &&) = default;
-};
-
-class ServiceStreaming : public Service {
- public:
-  enum {
-    kServiceType = 3,
-
-    kPrivilegePublishMixStream = 1,
-    kPrivilegePublishRawStream = 2,
-  };
-
- public:
-  ServiceStreaming(const std::string &channel_name = "", uint32_t uid = 0)
-      : Service(kServiceType), channel_name_(channel_name) {
-    if (uid == 0) {
-      account_ = "";
-    } else {
-      account_ = std::to_string(uid);
-    }
-  }
-
-  ServiceStreaming(const std::string &channel_name, const std::string &account)
-      : Service(kServiceType), channel_name_(channel_name), account_(account) {}
-
-  virtual std::string PackService() override { return Pack(this); }
-
-  virtual void UnpackService(Unpacker *unpacker) override { *unpacker >> this; }
-
-  virtual std::unique_ptr<Service> Clone() const override {
-    return std::unique_ptr<Service>(new ServiceStreaming(*this));
-  }
-
-  friend agora::tools::Packer &operator<<(agora::tools::Packer &p,
-                                          const ServiceStreaming *x) {
-    p << dynamic_cast<const Service *>(x) << x->channel_name_ << x->account_;
-    return p;
-  }
-
-  friend agora::tools::Unpacker &operator>>(agora::tools::Unpacker &p,
-                                            ServiceStreaming *x) {
-    p >> dynamic_cast<Service *>(x) >> x->channel_name_ >> x->account_;
-    return p;
-  }
-
- public:
-  std::string channel_name_;
-  std::string account_;
-
- protected:
-  ServiceStreaming(const ServiceStreaming &) = default;
-  ServiceStreaming(ServiceStreaming &&) = default;
-  ServiceStreaming &operator=(const ServiceStreaming &) = default;
-  ServiceStreaming &operator=(ServiceStreaming &&) = default;
-};
-
-class ServiceFpa : public Service {
- public:
-  enum {
-    kServiceType = 4,
-
-    kPrivilegeLogin = 1,
-  };
-
-  ServiceFpa() : Service(kServiceType) {}
-
-  virtual std::string PackService() override { return Pack(this); }
-  virtual void UnpackService(Unpacker *unpacker) override { *unpacker >> this; }
-
-  virtual std::unique_ptr<Service> Clone() const override {
-    return std::unique_ptr<Service>(new ServiceFpa(*this));
-  }
-
-  friend agora::tools::Packer &operator<<(agora::tools::Packer &p,
-                                          const ServiceFpa *x) {
-    return p << dynamic_cast<const Service *>(x);
-  }
-  friend agora::tools::Unpacker &operator>>(agora::tools::Unpacker &p,
-                                            ServiceFpa *x) {
-    return p >> dynamic_cast<Service *>(x);
-  }
-
- protected:
-  ServiceFpa(const ServiceFpa &) = default;
-  ServiceFpa(ServiceFpa &&) = default;
-  ServiceFpa &operator=(const ServiceFpa &) = default;
-  ServiceFpa &operator=(ServiceFpa &&) = default;
-};
-
 class ServiceChat : public Service {
  public:
   enum {
@@ -282,9 +154,6 @@ struct ServiceCreator {
 };
 static const std::map<uint16_t, Service *(*)()> kServiceCreator = {
     {ServiceRtc::kServiceType, ServiceCreator<ServiceRtc>::New},
-    {ServiceRtm::kServiceType, ServiceCreator<ServiceRtm>::New},
-    {ServiceStreaming::kServiceType, ServiceCreator<ServiceStreaming>::New},
-    {ServiceFpa::kServiceType, ServiceCreator<ServiceFpa>::New},
     {ServiceChat::kServiceType, ServiceCreator<ServiceChat>::New},
 };
 

DynamicKey/AgoraDynamicKey/cpp/src/RtcTokenBuilder2.h

@@ -57,17 +57,21 @@ class RtcTokenBuilder2 {
    In order for this role to take effect, please contact our support team to
    enable authentication for Hosting-in for you. Otherwise, Role_Subscriber
    still has the same privileges as Role_Publisher.
-   @param expire represented by the number of seconds elapsed since now. If, for
-   example, you want to access the Agora Service within 10 minutes after the
-   token is generated (both for token life cycle and privilege life cycle),
-   set expireTimestamp as 600(seconds).
+   @param token_expire represented by the number of seconds elapsed since now. If,
+   for example, you want to access the Agora Service within 10 minutes after the
+   token is generated, set token_expire as 600(seconds).
+   @param privilege_expire represented by the number of seconds elapsed since now. If, for
+   example, you want to enable your privilege for 10 minutes, set privilege_expire
+   as 600(seconds).
    @return The new Token.
    */
+
   static std::string BuildTokenWithUid(const std::string& app_id,
                                        const std::string& app_certificate,
                                        const std::string& channel_name,
                                        uint32_t uid, UserRole role,
-                                       uint32_t expire = 0);
+                                       uint32_t token_expire,
+                                       uint32_t privilege_expire = 0);
 
   /**
    Builds an RTC token using a string userAccount.
@@ -94,16 +98,18 @@ class RtcTokenBuilder2 {
    In order for this role to take effect, please contact our support team to
    enable authentication for Hosting-in for you. Otherwise, Role_Subscriber
    still has the same privileges as Role_Publisher.
-   @param expire represented by the number of seconds elapsed since now. If, for
-   example, you want to access the Agora Service within 10 minutes after the
-   token is generated, (both for token life cycle and privilege life cycle),
-   set expireTimestamp as 600(seconds).
+   @param token_expire represented by the number of seconds elapsed since now. If,
+   for example, you want to access the Agora Service within 10 minutes after the
+   token is generated, set token_expire as 600(seconds).
+   @param privilege_expire represented by the number of seconds elapsed since now. If, for
+   example, you want to enable your privilege for 10 minutes, set privilege_expire
+   as 600(seconds).
    @return The new Token.
    */
   static std::string BuildTokenWithUserAccount(
       const std::string& app_id, const std::string& app_certificate,
       const std::string& channel_name, const std::string& user_account,
-      UserRole role, uint32_t expire = 0);
+      UserRole role, uint32_t token_expire, uint32_t privilege_expire = 0);
 
   /**
   * Generates a RTC token with specified privileges.
@@ -214,29 +220,29 @@ class RtcTokenBuilder2 {
 inline std::string RtcTokenBuilder2::BuildTokenWithUid(
     const std::string& app_id, const std::string& app_certificate,
     const std::string& channel_name, uint32_t uid, UserRole role,
-    uint32_t expire) {
+    uint32_t token_expire, uint32_t privilege_expire) {
   std::string account;
   if (uid != 0) {
     account = std::to_string(uid);
   }
   return RtcTokenBuilder2::BuildTokenWithUserAccount(
-      app_id, app_certificate, channel_name, account, role, expire);
+      app_id, app_certificate, channel_name, account, role, token_expire, privilege_expire);
 }
 
 inline std::string RtcTokenBuilder2::BuildTokenWithUserAccount(
     const std::string& app_id, const std::string& app_certificate,
     const std::string& channel_name, const std::string& user_account,
-    UserRole role, uint32_t expire) {
+    UserRole role, uint32_t token_expire, uint32_t privilege_expire) {
   std::unique_ptr<Service> service(
       new ServiceRtc(channel_name, user_account));
-  service->AddPrivilege(ServiceRtc::kPrivilegeJoinChannel, expire);
+  service->AddPrivilege(ServiceRtc::kPrivilegeJoinChannel, privilege_expire);
   if (role == UserRole::kRolePublisher) {
-    service->AddPrivilege(ServiceRtc::kPrivilegePublishAudioStream, expire);
-    service->AddPrivilege(ServiceRtc::kPrivilegePublishVideoStream, expire);
-    service->AddPrivilege(ServiceRtc::kPrivilegePublishDataStream, expire);
+    service->AddPrivilege(ServiceRtc::kPrivilegePublishAudioStream, privilege_expire);
+    service->AddPrivilege(ServiceRtc::kPrivilegePublishVideoStream, privilege_expire);
+    service->AddPrivilege(ServiceRtc::kPrivilegePublishDataStream, privilege_expire);
   }
 
-  AccessToken2 generator(app_id, app_certificate, 0, expire);
+  AccessToken2 generator(app_id, app_certificate, 0, token_expire);
   generator.AddService(std::move(service));
 
   return generator.Build();