EncryptedMedia

@inject Bit.Butil.EncryptedMedia encryptedMedia

var access = await encryptedMedia.IsKeySystemSupported("com.widevine.alpha",
    new MediaKeySystemConfiguration
    {
        InitDataTypes = ["cenc"],
        VideoCapabilities =
        [
            new MediaKeySystemMediaCapability { ContentType = "video/mp4;codecs=\"avc1.42E01E\"", Robustness = "HW_SECURE_ALL" },
            new MediaKeySystemMediaCapability { ContentType = "video/mp4;codecs=\"avc1.42E01E\"", Robustness = "SW_SECURE_CRYPTO" },
        ]
    });

var robustness = access?.Configuration.VideoCapabilities?[0].Robustness; // what was actually granted

@inject HttpClient http
@inject Bit.Butil.EncryptedMedia encryptedMedia

@code {
    private MediaKeysHandle? keys;
    private MediaKeySessionHandle? session;

    private async Task Exchange(byte[] initData)
    {
        keys = await encryptedMedia.CreateMediaKeys("org.w3.clearkey", new MediaKeySystemConfiguration
        {
            InitDataTypes = ["keyids"],
            VideoCapabilities = [new MediaKeySystemMediaCapability { ContentType = "video/mp4;codecs=\"avc1.42E01E\"" }]
        });

        session = await keys!.CreateSession(
            onMessage: async message =>
            {
                // The message is opaque: post it to the licence server unchanged, and feed whatever
                // comes back straight into Update. Nothing here inspects either one.
                var licence = await RequestLicence(message.Message);
                await session!.Update(licence);
            },
            onKeyStatusesChange: statuses =>
            {
                foreach (var status in statuses) Console.WriteLine($"{status.KeyId}: {status.Status}");
            });

        await session!.GenerateRequest("keyids", initData);
    }

    private async Task<byte[]> RequestLicence(byte[] challenge)
    {
        var response = await http.PostAsync("/api/licence", new ByteArrayContent(challenge));
        return await response.Content.ReadAsByteArrayAsync();
    }
}

@implements IAsyncDisposable
@inject Bit.Butil.EncryptedMedia encryptedMedia

<video @ref="videoElement" controls></video>

@code {
    private ElementReference videoElement;
    private ButilSubscription? subscription;
    private MediaKeySessionHandle? session;   // from the exchange above

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender is false) return;

        subscription = await encryptedMedia.SubscribeEncrypted(videoElement, async initData =>
        {
            // one per protection system in the stream; filter by InitDataType, and by key ids you
            // already hold
            await session!.GenerateRequest(initData);
        });
    }

    public async ValueTask DisposeAsync()
    {
        if (subscription is not null) await subscription.DisposeAsync();
    }
}

@inject Bit.Butil.LocalStorage localStorage

@code {
    private MediaKeysHandle? keys;   // from CreateMediaKeys above

    private async Task GoOffline(byte[] certificateBytes, byte[] initData,
                                Action<MediaKeyMessage> onMessage)
    {
        // Optional, and only some key systems want it: it lets the CDM encrypt its challenge to a
        // licence server it can already identify.
        await keys!.SetServerCertificate(certificateBytes);

        var offline = await keys.CreateSession(onMessage, MediaKeySessionType.PersistentLicense);
        await offline!.GenerateRequest(initData);

        // The id is the only way back to the stored licence - the session itself does not survive.
        var storedId = await offline.GetSessionId();
        await localStorage.SetItem("licence-session", storedId);
    }

    private async Task Restore(Action<MediaKeyMessage> onMessage)
    {
        var storedId = await localStorage.GetItem("licence-session");

        // next time, with no network at all:
        var restored = await keys!.CreateSession(onMessage, MediaKeySessionType.PersistentLicense);
        await restored!.Load(storedId);

        await restored.Remove();   // releases the licence and deletes the stored copy
    }
}