Get best of the week

Recebendo mensagens de transmissões do youtube + autorização do google em PHP

No outro dia, houve uma tarefa de receber mensagens do stream do youtube. Não encontrei artigos sobre esse assunto, mas existem apenas desvantagens. documentação do google Eu descobri (espero) e estou pronto para compartilhar minha experiência com você.

imagem

A primeira coisa que encontrei foi o método LiveChatMessages: list , parece que tudo é simples, mas o parâmetro necessário é passar o liveChatId, que você pode obter fazendo uma solicitação ao LiveBroadcasts: list , mas para fazer uma solicitação lá, é necessário autorizar o usuário pelo google com acesso a conta de leitura. Nos exemplos, tudo está detalhado em detalhes, mas se você estiver lendo este artigo, pode não ser tão claro quanto gostaríamos.

Conecte-se


Consola do Google


Usando o OAuth 2.0 para aplicativos de servidor da Web , quero observar imediatamente que a autorização do servidor da Web é necessária, porque a chave transmitida durante a autorização para js dura uma hora e não será atualizada (sem a participação do usuário). o token de atualização não é transmitido. Além disso, eu recomendo usar uma das bibliotecas prontas, tudo será muito mais fácil com elas.

Primeiro, crie uma conta. Acesse console.developers.google.com , selecione os projetos no canto superior esquerdo e clique em "Criar projeto".



Digite um nome e salve. Agora selecione seu projeto e clique em "Ativar APIs e serviços" ou acesse a página da biblioteca de APIs .
Aqui, na consulta de pesquisa, encontre e ative a API de dados do YouTube v3.

Em seguida, na guia "Janela de solicitação de acesso OAuth" no painel esquerdo do console ( ou aqui ), crie uma janela.
Na primeira etapa, selecione "Externo" para o Tipo de usuário.



Em seguida, neste formulário, é necessário preencher 2 campos - o nome do aplicativo e "Domínios autorizados", se você tiver um domínio, deixe o campo vazio, se não houver nenhum. Clique em salvar. O resultado deve ser algo como



Agora vá para a guia "Credenciais" (https://console.developers.google.com/apis/credentials).

Aqui você encontrará uma página:



Selecione o botão "Criar credenciais" -> "Identificador Cliente OAuth »
Selecione o tipo que você deseja (para nós, a web), digite o nome e "URIs de redirecionamento permitido" - esse é o URL para o qual o código será enviado para autorizar o cliente. Você pode escrever aqui um URL local no momento do desenvolvimento, no meu caso, será
http: // localhost: 8080 / oauth2callback.php

Resultado




Depois disso, uma janela com o ID do cliente e a chave secreta deve aparecer. Enquanto isso estiver fechando com segurança. Aqui está uma página com as credenciais recém -criadas.Clique



no botão Download para obter um identificador:



Você pode renomeá-la imediatamente para secret_json.json.

Isso é feito com a configuração da autorização, agora vamos ao código.

Php


Crie um projeto, abra um terminal e execute o comando:

php composer.phar require google/apiclient:^2.0

Se você não sabe o que é o compositor e como instalá-lo, familiarize-se.
Após a instalação, crie 2 arquivos - index.php e oauth2callback.php. A
propósito, você já pode iniciar o servidor PHP:

php -S localhost:8080

Mova também o arquivo secret_json.json (que você baixou anteriormente) para a pasta do projeto.

Diretamente no Index.php, você enviará o usuário para autorização. Conteúdo do arquivo Index.php

<?php
require_once __DIR__ . '/vendor/autoload.php';

$client = new Google_Client();
//     
$client->setAuthConfig('client_secret.json');
//   
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
//    refresh_token
$client->setAccessType("offline");

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
    $client->setAccessToken($_SESSION['access_token']);
} else {
    $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
    header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
    exit();
}

$refreshToken = $_SESSION['access_token']['refresh_token'];
$accessToken = $_SESSION['access_token']['access_token'];
$tknType = $_SESSION['access_token']['token_type'];
$clientId = $client->getClientId();
$created = $_SESSION['access_token']['created'];
unset($_SESSION['access_token']);
unset($_SESSION['user']);
session_destroy();

$data = json_encode([
  'refreshToken' => $refreshToken,
    'accessToken' => $accessToken,
    'tknType' => $tknType,
    'clientId' => $clientId,
    'created' => $created
]);
echo $data;

De fato, esse código fornecerá ao usuário todos os dados necessários, você poderá gravá-los no banco de dados (ou no bloco de notas).

Arquivo oauth2callback.php:

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google_Client();
$client->setAuthConfigFile('client_secret.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
$client->setApprovalPrompt('force');
$client->setAccessType("offline");

if (!isset($_GET['code'])) {
    $auth_url = $client->createAuthUrl();
    header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
    $client->authenticate($_GET['code']);
    $_SESSION['access_token'] = $client->getAccessToken();
    $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
    header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Esse arquivo redirecionará o usuário para a página de autorização do Google e gravará os dados do token na sessão. Depois, ele retornará ao usuário para onde index.php continuará trabalhando com eles.
Obviamente, você pode gravar todos os dados diretamente no oauth2callback e não redirecionar o usuário de volta ao índice, ou pode especificar no próximo ponto qualquer endereço conveniente para você. Além disso, os erros de autorização não foram levados em consideração neste código, lembre-se disso.

Isso é feito com autorização. Você já tem access_token e refresh_token, vamos ao YouTube.

Youtube


PHP imediatamente


getStreams.php:

<?php
require_once __DIR__ . '/vendor/autoload.php';
//   
require_once __DIR__ . '/refreshToken.php';

$client = new Google_Client();
$client->setAuthConfig('client_secret.json');
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
$client->setAccessType("offline");

//  $data      (   )
if (($data['created'] - time()) <= -3600) {
    $data = refreshToken($data['refreshToken'], $db);
}

$client->setAccessToken($data['accessToken']);
$service = new Google_Service_YouTube($client);
//  2          , 
//       .
$queryParams = [
    'broadcastStatus' => 'upcoming',
    'maxResults' => 50
];
$response = $service->liveBroadcasts->listLiveBroadcasts('id,snippet,status', $queryParams);
$items = $response['items'];
$streamsUpcoming = itemsGenerator($items);

$queryParams = [
    'broadcastStatus' => 'active',
    'maxResults' => 50
];
$response = $service->liveBroadcasts->listLiveBroadcasts('id,snippet,status', $queryParams);
$items = $response['items'];
$streamsActive = itemsGenerator($items);
$streams = array_merge($streamsUpcoming, $streamsActive);

//  
echo json_encode($streams);

//     ,   .
function itemsGenerator($items) {
    $streams = [];
    foreach ($items as $item) {
        //       (  )
        if (!isset($item['snippet']['actualEndTime'])) {
            $streams[] = [
                'id' => $item['id'],
                'title' => $item['snippet']['title'],
                'description' => $item['snippet']['description'],
                'image' => $item['snippet']['thumbnails']['medium']['url'],
                'liveChatId' => $item['snippet']['liveChatId'],
                'channelId' => $item['snippet']['channelId']
            ];
        }
    }
    return $streams;
}

Lembra dessas linhas durante a autorização?

$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);

Portanto, eles são responsáveis ​​por que tipo de acesso você precisa. Por exemplo, esse registro permite apenas a leitura de informações, existem https://www.googleapis.com/auth/youtube.uploadoutras.

refreshToken.php:

<?php
require_once __DIR__ . '/vendor/autoload.php';

/**
 * @param string $refreshToken
 * @param $db
 * @return array
 * @throws Google_Exception
 */
function refreshToken($refreshToken, $db)
{
    $client = new Google_Client();
    $client->setAuthConfig('client_secret.json');
    $client->setScopes([
        'https://www.googleapis.com/auth/youtube.readonly',
    ]);
    $client->setAccessType("offline");

    $client->refreshToken($refreshToken);
    $accessToken = $client->getAccessToken();

    $refreshToken = $accessToken['refresh_token'];
    $accessToken = $accessToken['access_token'];
    $clientId = $client->getClientId();
    $data = [
        'refreshToken' => $refreshToken,
        'accessToken' => $accessToken,
        'tknType' => 'Bearer',
        'clientId' => $clientId,
        'created' => time()
    ];

    //      , .

    return $data;
}

O token emitido pelo Google é válido apenas por uma hora. Durante o dia, você pode fazer apenas 25 solicitações para atualizar o token, essa função apenas atualiza nosso token e retorna novos valores com os quais você pode continuar trabalhando. GetStreams demonstra seu trabalho.

E, finalmente,
getStreamMessages.php:

<?php
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/refreshToken.php';

$client = new Google_Client();
$client->setAuthConfig('client_secret.json');
$client->setScopes([
    'https://www.googleapis.com/auth/youtube.readonly',
]);
$client->setAccessType("offline");
// $data -      
if (($data['created'] - time()) <= -3600) {
    $data = refreshToken($data['refreshToken'], $db);
}
$client->setAccessToken($data['accessToken']);

$service = new Google_Service_YouTube($client);

$queryParams = [
    'maxResults' => 2000,
    'profileImageSize' => 120
];

$response = $service->liveChatMessages->listLiveChatMessages($liveChatId, 'id,snippet,authorDetails', $queryParams);

echo json_encode($response);

Aqui, não comecei a colocar o formato da mensagem no formato desejado, você pode fazer isso sozinho, a matriz $ response contém todas as informações necessárias e o link para o artigo está aqui .

O que me chateou é que não existe um método para obter ganchos (se houver um, deixe um link, por favor) e você precisa fazer solicitações constantes.

Além disso, eu recomendo a leitura da documentação do liveChatMessages, existem algumas restrições, como você precisa fazer uma solicitação para cada página com um novo código que veio na solicitação anterior.

Projeto Github com db (tudo o que resta é fazer upload do arquivo client_secret.json)

More articles:


All Articles