Início / user-9171697

ph3rin's questions

Martin Hope
ph3rin
Asked: 2025-02-08 00:11:28 +0800 CST
  • 5

Quero criar um fluxo que possa emitir um único valor para cada assinante, não importa quando ele se inscreveu.

O ideal seria que o código a seguir imprimisse dois 42antes de done, mas nenhuma das abordagens fornecidas funciona.

void main() async {
  final stream = createStream(42);
  stream.listen(printValue);
  await Future.delayed(Duration(seconds: 1));
  stream.listen(printValue);

  // Wait for everything to finish.
  await Future.delayed(Duration(seconds: 1));
  print('done');
}

Stream<int> createStream(int val) {
  // Error: Stream has already been listened to.
  // return Stream.value(val);

  // Only gets one output
  return Stream.value(val).asBroadcastStream();
}

void printValue(int val) {
  print(val);
}

Saída desejada:

42
42
done

Mas Stream.value()gera um erro Stream has already been listened to.. Enquanto .asBroadcastStream()dá o resultado errado.

Observação: respostas usando o RxDart serão bem-vindas.

flutter
Martin Hope
ph3rin
Asked: 2024-12-31 17:27:22 +0800 CST
  • 9

Eu estava tentando encontrar uma maneira de mixar fluxos de áudio com WebAudio e gravá-los com um MediaRecorder. Tenho seguido a abordagem descrita aqui:

Grave várias faixas de áudio disponíveis em um fluxo com o MediaRecorder

Parece que um nó de ganho (no exemplo deles, o nó de destino) pode executar mixagem em vários fluxos, como mostrado pelo meu experimento abaixo. No exemplo, você pode ouvir o tema Caribbean Pirates e o tema Universal Studios tocando quando você aperta o recordbotão.

Entretanto, no MDN diz que o nó de ganho (assim como o nó de destino) tem uma contagem de entrada de 1 .

Número de entradas = 1 insira a descrição da imagem aqui

Intuitivamente, algo com uma única entrada não pode executar mixagem! Estou esquecendo de algo aqui?

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Web Audio Track Recorder</title>
</head>
<body>
  <h1>Web Audio Track Recorder</h1>
  <button id="recordButton">Start Recording</button>
  <script src="script.js"></script>
</body>
</html>

script.js

// URLs of the audio tracks:
const track1Url = 'https://archive.org/download/tvtunes_13046/Pirates%20of%20the%20Caribbean%20-%20Hes%20a%20Pirate.mp3';
const track2Url = 'https://archive.org/download/tvtunes_7590/Universal%20Studios.mp3';

// Initialize variables
let audioContext;
let source1, source2;
let mediaRecorder;
let audioChunks = [];
let isRecording = false;

// Function to start the audio context and load tracks
async function startAudio() {
  audioContext = new (window.AudioContext || window.webkitAudioContext)();

  // Load and decode the audio tracks
  const track1Data = await fetch(track1Url).then(response => response.arrayBuffer());
  const track2Data = await fetch(track2Url).then(response => response.arrayBuffer());

  const track1Buffer = await audioContext.decodeAudioData(track1Data);
  const track2Buffer = await audioContext.decodeAudioData(track2Data);

  // Create buffer sources
  source1 = audioContext.createBufferSource();
  source2 = audioContext.createBufferSource();

  source1.buffer = track1Buffer;
  source2.buffer = track2Buffer;

  // Create a gain node to control the volume
  const gainNode = audioContext.createGain();
  gainNode.gain.setValueAtTime(0.25, audioContext.currentTime);

  // Connect sources to the gain node
  source1.connect(gainNode);
  source2.connect(gainNode);

  // Connect gain node to the destination (speakers)
  gainNode.connect(audioContext.destination);

  // Create a MediaStream from the audio context
  const destination = audioContext.createMediaStreamDestination();
  gainNode.connect(destination);

  // Initialize MediaRecorder with the audio stream
  mediaRecorder = new MediaRecorder(destination.stream);

  // Event handler for when data is available
  mediaRecorder.ondataavailable = event => {
    audioChunks.push(event.data);
  };

  // Event handler for when recording stops
  mediaRecorder.onstop = () => {
    const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
    const audioUrl = URL.createObjectURL(audioBlob);
    const downloadLink = document.createElement('a');
    downloadLink.href = audioUrl;
    downloadLink.download = 'recording.webm';
    downloadLink.click();
    audioChunks = [];
  };

  // Start the sources
  source1.start();
  source2.start();
}

// Function to toggle recording
function toggleRecording() {
  if (!isRecording) {
    if (!audioContext) {
      startAudio().then(() => {
        mediaRecorder.start();
        document.getElementById('recordButton').textContent = 'Stop Recording';
      });
    } else {
      mediaRecorder.start();
      document.getElementById('recordButton').textContent = 'Stop Recording';
    }
  } else {
    mediaRecorder.stop();
    document.getElementById('recordButton').textContent = 'Start Recording';
  }
  isRecording = !isRecording;
}

// Add event listener to the record button
document.getElementById('recordButton').addEventListener('click', toggleRecording);

Você também pode tentar aqui: https://jsfiddle.net/10ms7pyd/8/

javascript
Martin Hope
ph3rin
Asked: 2024-12-18 01:24:22 +0800 CST
  • 5

Temos um aplicativo móvel com funcionalidade de inscrição (pense nele como um lambda da AWS), que é acessível publicamente.

Durante o desenvolvimento, implantamos em uma conta AWS sandbox. Queremos que o sistema dev proíba a inscrição pública, mas ainda permita que o desenvolvedor se inscreva por meio de um front-end especificamente configurado (ou seja, com as chaves secretas necessárias).

O raciocínio para isso é que não queremos que atores maliciosos consigam falar com nossos sistemas de desenvolvimento! Como estamos fazendo serverless, é difícil aplicar isolamento em nível de rede, então toda a segurança deve vir da autenticação. Também queremos manter a maioria do trabalho de autenticação e autorização para o IAM porque chamadas não autorizadas para lambdas não incorrem em custo.

Minha solução atual é:

Na produção, anexe uma política baseada em recursos à função Lambda de inscrição, permitindo explicitamente a invocação pública (Principal: "*")para lambda:InvokeFunction.

Em desenvolvimento, anexe uma Denydeclaração às funções Lambda marcadas com dev_protect = true. Esta regra de negação bloqueia a invocação se o chamador não tiver uma tag principal developer = true. Adicione esta tag às funções do desenvolvedor, que o front-end usa para inscrição.

Aqui está o exemplo das políticas:

Produção (Acesso Público a sign-up):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPublicInvokeForSignUp",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:sign-up"
    }
  ]
}

Desenvolvimento (Negar acesso a dev_protectfunções sem developertag):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "DenyNonDeveloperAccessToDevProtected",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "lambda:InvokeFunction",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:*",
      "Condition": {
        "StringEquals": {
          "aws:ResourceTag/dev_protect": "true"
        },
        "ForAnyValue:StringNotEqualsIfExists": {
          "aws:PrincipalTag/developer": "true"
        }
      }
    }
  ]
}

Essa é uma boa abordagem ou existem outras melhores para o meu problema?

Martin Hope
ph3rin
Asked: 2024-12-12 21:45:50 +0800 CST
  • 5

Digamos que eu esteja administrando um fórum, onde cada usuário pode fazer várias postagens.

Então eu estruturei meu banco de dados da seguinte maneira: (com colunas não relacionadas omitidas)

PK Eslováquia CADEIA_0
POST,post_id thread,seq_num ID do usuário
USUÁRIO,id_do_usuário NÃO_RELEVANTE grandes_meta_dados

Um caso de uso comum é renderizar um tópico de discussão inteiro, com todas as postagens dentro dele. No entanto, sempre que renderizamos uma postagem, renderizaremos alguns metadados do usuário que são representados acima como big_meta_data(Isso pode incluir a imagem do perfil do usuário, a reputação do usuário, etc.)

Claro que podemos primeiro executar uma consulta para obter todas as postagens e, então, para cada usuário que vemos, executamos uma consulta adicional (provavelmente em lote).

Existe alguma maneira de evitar consultas extras aos registros do usuário ou o acima é suficiente?

A única maneira que consigo pensar é manter uma cópia disso big_meta_datanas linhas POST, mas isso parece difícil de gerenciar e consome armazenamento extra.