GoとTwilioで通話システムを構築する ── Conference・TwiML・VoIP・録音の実装パターン

1

go get github.com/twilio/twilio-go

1
2
3
4
5
6

import "github.com/twilio/twilio-go"

client := twilio.NewRestClientWithParams(twilio.ClientParams{
    Username: "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // Account SID
    Password: "your_auth_token",                    // Auth Token
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import "github.com/twilio/twilio-go/twiml"

func sayXML(message string) (string, error) {
    say := &twiml.VoiceSay{
        Language: "ja-JP",
        Voice:    "Polly.Mizuki",  // Amazon Polly の日本語音声
        Message:  message,
    }
    return twiml.Voice([]twiml.Element{say})
}

1
2
3
4

<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say language="ja-JP" voice="Polly.Mizuki">こんにちは</Say>
</Response>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func joinConferenceXML(roomName, statusCallbackURL string) (string, error) {
    say := &twiml.VoiceSay{
        Language: "ja-JP",
        Voice:    "Polly.Mizuki",
        Message:  "担当者にお繋ぎしますので、少々お待ちください。",
    }

    conference := &twiml.VoiceConference{
        Name:                   roomName,
        StartConferenceOnEnter: "false",
        EndConferenceOnExit:    "true",
        StatusCallbackEvent:    "start end join leave",
        StatusCallback:         statusCallbackURL,
        StatusCallbackMethod:   "POST",
        WaitUrl:                "http://com.twilio.music.classical.s3.amazonaws.com/ith_brahms-116-4.mp3",
        WaitMethod:             "GET",
    }

    dial := &twiml.VoiceDial{
        InnerElements: []twiml.Element{conference},
    }

    return twiml.Voice([]twiml.Element{say, dial})
}

1
2
3
4
5
6
7

conference := &twiml.VoiceConference{
    Name:                   roomName,
    StartConferenceOnEnter: "true",
    EndConferenceOnExit:    "true",
    Record:                 "record-from-start",
    Trim:                   "do-not-trim",
}

1
2
3
4
5

func waitInConferenceXML(roomName string) (string, error) { ... }    // 待機側入室
func startConferenceXML(roomName string) (string, error) { ... }     // 開始側入室（録音付き）
func gatherPasswordXML(actionURL string) (string, error) { ... }     // パスワード入力要求
func callEndReminderXML(minutes int) (string, error) { ... }         // 残り時間アナウンス
func hangupWithMessageXML(message string) (string, error) { ... }    // メッセージ後切断

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import api "github.com/twilio/twilio-go/rest/api/v2010"

params := &api.CreateCallParams{}
params.SetTo("+819012345678")
params.SetFrom("+815012345678")
params.SetUrl("https://example.com/twiml/answer")  // 応答時のTwiML URL
params.SetStatusCallback("https://example.com/callback/status")
params.SetStatusCallbackEvent([]string{"answered", "completed"})
params.SetTimeout(45) // 着信タイムアウト（秒）

resp, err := client.Api.CreateCall(params)
if err != nil {
    log.Fatal(err)
}
fmt.Println("CallSid:", *resp.Sid)

1
2

xml, _ := joinConferenceXML("room-123", callbackURL)
params.SetTwiml(xml)  // Urlの代わりにTwiMLを直接指定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

params := &api.UpdateCallParams{}

// パターン1: 新しいTwiMLを適用（アナウンス後に切断など）
xml, _ := hangupWithMessageXML("まもなく通話が終了します。")
params.SetTwiml(xml)

// パターン2: 強制切断
// params.SetStatus("completed")

resp, err := client.Api.UpdateCall("CAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", params)

1
2
3
4
5

params := &api.UpdateConferenceParams{}
params.SetAnnounceUrl("https://example.com/twiml/reminder")
params.SetAnnounceMethod("POST")

_, err := client.Api.UpdateConference("CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", params)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

func gatherPasswordXML(actionURL string) (string, error) {
    say := &twiml.VoiceSay{
        Language: "ja-JP",
        Voice:    "Polly.Mizuki",
        Message:  "4桁のパスワードを入力してください。",
    }

    gather := &twiml.VoiceGather{
        Input:         "dtmf",
        Timeout:       "30",
        NumDigits:     "4",
        Action:        actionURL,  // 入力結果の送信先
        Method:        "POST",
        InnerElements: []twiml.Element{say},
    }

    noInputSay := &twiml.VoiceSay{
        Language: "ja-JP",
        Voice:    "Polly.Mizuki",
        Message:  "入力がありませんでした。通話を終了します。",
    }
    hangup := &twiml.VoiceHangup{}

    return twiml.Voice([]twiml.Element{gather, noInputSay, hangup})
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import "crypto/subtle"

const maxPasswordAttempts = 3

func handlePasswordCallback(w http.ResponseWriter, r *http.Request) {
    digits := r.FormValue("Digits")
    attempt := getAttemptCount(r) // 1始まり。クエリパラメータやセッションで管理

    var xml string
    if len(expectedPassword) == 0 {
        xml, _ = hangupWithMessageXML("システムエラーが発生しました。")
    } else if subtle.ConstantTimeCompare([]byte(digits), []byte(expectedPassword)) == 1 {
        xml, _ = startConferenceXML("room-123")
    } else if attempt >= maxPasswordAttempts {
        xml, _ = hangupWithMessageXML("認証に失敗しました。通話を終了します。")
    } else {
        xml, _ = gatherPasswordRetryXML(actionURL, attempt+1)
    }

    w.Header().Set("Content-Type", "application/xml")
    w.Write([]byte(xml))
}

1

params.SetTo("+819012345678")

1

params.SetMachineDetection("Enable")

1

params.SetTo("client:user-12345")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import twilioJwt "github.com/twilio/twilio-go/client/jwt"

accessToken := twilioJwt.CreateAccessToken(twilioJwt.AccessTokenParams{
    AccountSid:    accountSid,
    SigningKeySid: apiKeySid,
    Secret:        apiSecret,
    Identity:      "user-12345",
    Ttl:           3600, // トークン有効期間（秒）
})

accessToken.AddGrant(&twilioJwt.VoiceGrant{
    Outgoing: twilioJwt.Outgoing{
        ApplicationSid: twimlAppSid,
    },
    Incoming: twilioJwt.Incoming{
        Allow: true,
    },
    PushCredentialSid: pushCredentialSid, // APNs or FCM
})

jwtToken, err := accessToken.ToJwt()

1
2
3
4
5
6

if strings.HasPrefix(to, "client:") {
    // VoIP: AMDは不要
} else {
    // PSTN: AMD有効化を検討
    params.SetMachineDetection("Enable")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

var (
    reNonDigit = regexp.MustCompile(`\D`)
    reE164     = regexp.MustCompile(`^\+[1-9]\d{1,14}$`)
)

func toE164Japan(phoneNumber string) (string, error) {
    // 既にE.164形式なら検証して素通し
    if strings.HasPrefix(phoneNumber, "+") {
        if !reE164.MatchString(phoneNumber) {
            return "", fmt.Errorf("無効なE.164番号: %s", phoneNumber)
        }
        return phoneNumber, nil
    }

    // ハイフンなどの非数字を除去
    cleaned := reNonDigit.ReplaceAllString(phoneNumber, "")

    // 国内番号の先頭が0であることを確認
    if len(cleaned) == 0 || cleaned[0] != '0' {
        return "", fmt.Errorf("無効な国内電話番号: %s", phoneNumber)
    }

    // 国内番号は10桁（固定）または11桁（携帯）
    if len(cleaned) < 10 || len(cleaned) > 11 {
        return "", fmt.Errorf("無効な桁数の電話番号: %s", phoneNumber)
    }

    // 先頭の0を+81に置換
    return "+81" + cleaned[1:], nil
}

// "090-1234-5678" → "+819012345678"
// "+819012345678" → "+819012345678"（そのまま返す）

1
2
3
4
5
6
7
8

func toLocalFormat(e164 string) string {
    if strings.HasPrefix(e164, "+81") {
        return "0" + e164[3:]
    }
    return e164
}

// "+819012345678" → "09012345678"

1
2
3
4
5
6
7
8
9

conference := &twiml.VoiceConference{
    Name:                          roomName,
    StartConferenceOnEnter:        "true",
    Record:                        "record-from-start",
    Trim:                          "do-not-trim",
    RecordingStatusCallback:       "https://example.com/callback/recording",
    RecordingStatusCallbackMethod: "POST",
    RecordingStatusCallbackEvent:  "completed",
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

func downloadRecording(recordingURL, accountSid, authToken string) (io.ReadCloser, error) {
    // SSRF対策: Twilio APIのURLであることを検証
    if err := validateRecordingURL(recordingURL); err != nil {
        return nil, err
    }

    // MP3形式でデュアルチャンネル（話者分離）ダウンロード
    downloadURL := recordingURL + ".mp3?RequestedChannels=2"

    req, err := http.NewRequest(http.MethodGet, downloadURL, nil)
    if err != nil {
        return nil, err
    }
    req.SetBasicAuth(accountSid, authToken)

    client := &http.Client{
        Timeout: 5 * time.Minute,
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            if len(via) >= 10 {
                return fmt.Errorf("リダイレクトが多すぎます")
            }
            return validateRecordingURL(req.URL.String())
        },
    }
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    if resp.StatusCode != http.StatusOK {
        resp.Body.Close()
        return nil, fmt.Errorf("録音ダウンロード失敗: status=%d", resp.StatusCode)
    }

    return resp.Body, nil
}

1
2
3
4
5
6
7
8

const twilioAPIBaseURL = "https://api.twilio.com/"

func validateRecordingURL(url string) error {
    if !strings.HasPrefix(url, twilioAPIBaseURL) {
        return fmt.Errorf("不正なRecordingURL: Twilio APIのURLではありません")
    }
    return nil
}

1
2
3
4
5

// StatusCallbackEventに "join" を含めると、参加者入室時にコールバックが届く
conference := &twiml.VoiceConference{
    StatusCallbackEvent: "start end join leave",
    StatusCallback:      callbackURL,
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import "github.com/twilio/twilio-go/client"

func validateTwilioRequest(r *http.Request, baseURL, authToken string) bool {
    requestValidator := client.NewRequestValidator(authToken)

    fullURL := baseURL + r.URL.RequestURI()
    params := make(map[string]string)
    if err := r.ParseForm(); err != nil {
        return false
    }
    for key, values := range r.PostForm {
        params[key] = values[0]
    }
    signature := r.Header.Get("X-Twilio-Signature")

    return requestValidator.Validate(fullURL, params, signature)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

type TwilioConfig struct {
    AccountSID            string
    AuthToken             string
    PhoneNumber           string
    TwiMLAppSID           string
    APIKeySID             string
    APISecret             string
    PushCredentialSIDiOS  string
    PushCredentialSIDFCM  string
}

1

params.SetTimeout(45)

1
2
3
4
5
6
7

func voiceWithPause(elements ...twiml.Element) (string, error) {
    all := make([]twiml.Element, 0, len(elements)+2)
    all = append(all, &twiml.VoicePause{Length: "1"})
    all = append(all, elements...)
    all = append(all, &twiml.VoicePause{Length: "1"})
    return twiml.Voice(all)
}

1

Trim: "do-not-trim"

1

client := &http.Client{Timeout: 5 * time.Minute}