ZEGOCLOUD

https://www.zegocloud.com/docs
Admin
ZEGOCLOUD provides APIs and UI Kits for developers to integrate real-time communication features...
Tokens:3,307
Snippets:11
Trust Score:9.7
Update:11 months ago
Show doc for...
Tokens:
Raw
### Log in to a Room with Token (Swift)

Source: https://www.zegocloud.com/docs/video-call/token

This Swift code demonstrates how to log in to a ZEGOCLOUD room using the `loginRoom` method. It requires the `roomID`, a `ZegoUser` object with a `userID`, and a `ZegoRoomConfig` object where the `token` must be provided. The `userID` used for login must match the one used for token generation.

```swift
import ZegoExpressSDK

func loginToRoom() {
    let roomID: String = "your_room_id" // Replace with actual room ID
    let user = ZegoUser(userID: "your_user_id") // Replace with actual user ID
    let config = ZegoRoomConfig()
    config.token = "your_generated_token" // Replace with your generated token

    ZegoExpressEngine.shared().loginRoom(roomID, user: user, config: config) {
        error, extendedData in
        if let error = error {
            print("Failed to login to room: \(error.code) - \(error.message)")
        } else {
            print("Successfully logged in to room: \(roomID)")
        }
    }
}
```

--------------------------------

### Generate RTC Room Token with Payload (Go)

Source: https://www.zegocloud.com/docs/video-call/token

This Go code snippet demonstrates how to generate a token for an RTC room. It involves setting token validity, defining user privileges, creating a payload with room and privilege information, marshalling the payload to JSON, and finally generating the token using `token04.GenerateToken04`. Ensure `appId`, `userId`, and `serverSecret` are correctly configured.

```go
package main

import (
	"encoding/json"
	"fmt"
	"token04"
)

type RtcRoomPayLoad struct {
	RoomId       string
	Privilege    map[int]int
	StreamIdList []string
}

func main() {
	var effectiveTimeInSeconds int64 = 3600
	privilege := make(map[int]int)
	privilege[token04.PrivilegeKeyLogin] = token04.PrivilegeEnable
	privilege[token04.PrivilegeKeyPublish] = token04.PrivilegeEnable

	payloadData := &RtcRoomPayLoad{
		RoomId:       "your_room_id", // Replace with actual room ID
		Privilege:    privilege,
		StreamIdList: nil,
	}

	payload, err := json.Marshal(payloadData)
	if err != nil {
		fmt.Println(err)
		return
	}

	// Replace with your actual App ID, User ID, and Server Secret
	appId := uint32(123456789)
	userId := "your_user_id"
	serverSecret := "your_server_secret"

	token, err := token04.GenerateToken04(appId, userId, serverSecret, effectiveTimeInSeconds, string(payload))
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("Generated Token:", token)
}
```

--------------------------------

### Generate User Privilege Token in Go

Source: https://www.zegocloud.com/docs/video-call/token

Generates a user privilege token for ZEGOCLOUD applications using Go. This token validates user privileges within RTC rooms, such as login or stream publishing rights. It requires AppID, UserID, ServerSecret, effective time, and a structured payload defining room ID, privileges, and stream lists.

```go
package main

import (
    "encoding/json"
    "fmt"
    "github.com/ZEGOCLOUD/zego_server_assistant/token/go/src/token04"
)

/*
Sample code for generating a user privilege Token:
 */


//Token-based business logic: RTC room-related authentication property 
type RtcRoomPayLoad struct {
    RoomId       string      `json:"room_id"`           //Room ID: used to to validate the room.
    Privilege    map[int]int `json:"privilege"`         //User privilege authentication control list: used to validate user privileges 
    StreamIdList []string    `json:"stream_id_list"`    //Stream list: used to validate the stream. This value can be null, and no stream will be validated if it is null.
}

func main() {
    var appId uint32 = 1
    roomId := "demo"
    userId := "demo"
    serverSecret := "fa94dd0f974cf2e293728a526b028271"

```

--------------------------------

### Generate User Identity Token in Go

Source: https://www.zegocloud.com/docs/video-call/token

Generates a user identity token for ZEGOCLOUD applications using the Go programming language. This token is used to verify user identity. It requires AppID, UserID, ServerSecret, and effective time. The payload field should be null for user identity tokens.

```go
package main

import (
    "fmt"
    "github.com/ZEGOCLOUD/zego_server_assistant/token/go/src/token04"
)

/*
Sample code for generating a user identity Token: 
*/

func main() {
    var appId uint32 = 1
    userId := "demo"
    serverSecret := "fa94dd0f974cf2e293728a526b028271"
    var effectiveTimeInSeconds int64 = 3600
    var payload string = ""

    token, err := token04.GenerateToken04(appId, userId, serverSecret, effectiveTimeInSeconds, payload)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(token)
}
```

--------------------------------

### Swift: Renew Token via onRoomTokenWillExpire Callback

Source: https://www.zegocloud.com/docs/video-call/token

This snippet shows how to implement the `onRoomTokenWillExpire` callback in Swift to request a new token from your app server and then use the `renewToken` method to update the SDK with the new token. This ensures uninterrupted service before the current token expires.

```swift
func onRoomTokenWillExpire(_ remainTimeInSecond: Int32, roomID: String) {
      let token:String = MyToken.getToken()// Request a new Token from app server.
      ZegoExpressEngine.shared().renewToken(token, roomID: roomID)
}
```

--------------------------------

### Renew Token for Stream Publishing Privilege (Swift)

Source: https://www.zegocloud.com/docs/video-call/token

This Swift code shows how to renew a token using the `renewToken` method in ZEGOCLOUD. This is typically done to update a user's stream publishing privileges after they have already logged into a room. The new token will apply to subsequent stream publishing actions, not current ones. You need to obtain a new token from your app server first.

```swift
import ZegoExpressSDK

func renewRoomToken() {
    let roomID = "your_room_id" // Replace with actual room ID
    // Assume MyToken.getToken() fetches a new, valid token from your app server
    let newToken: String = MyToken.getToken() // Replace with your token fetching logic

    ZegoExpressEngine.shared().renewToken(newToken, roomID: roomID) {
        error in
        if let error = error {
            print("Failed to renew token: \(error.code) - \(error.message)")
        } else {
            print("Token renewed successfully for room: \(roomID)")
        }
    }
}

// Placeholder for token fetching logic
class MyToken {
    static func getToken() -> String {
        // In a real application, you would request a new token from your app server here.
        // For demonstration purposes, returning a dummy token.
        return "newly_generated_token_string"
    }
}
```
Tokens:
Raw