Azure Project Condenser

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="newvideo.MainPage">

    <StackLayout>
        <Frame BackgroundColor="#2196F3" Padding="24" CornerRadius="0">
            <Label Text="Start recording video!" HorizontalTextAlignment="Center" TextColor="White" FontSize="36"/>
        </Frame>
        <Button Text="Take Video" Clicked="Capture_Video" x:Name="videoButton" />
    </StackLayout>

</ContentPage>

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:versionCode="1" android:versionName="1.0" package="com.companyname.newvideo" android:installLocation="auto">
	<uses-sdk android:minSdkVersion="25" android:targetSdkVersion="26" />
	<application android:label="newvideo.Android" android:theme="@style/MainTheme"></application>
	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
	<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
	<uses-permission android:name="android.permission.READ_INTERNAL_STORAGE" />
	<uses-permission android:name="android.permission.WRITE_INTERNAL_STORAGE" />
	<uses-permission android:name="android.permission.CAMERA" />
	<uses-permission android:name="android.permission.RECORD_AUDIO" />
	<uses-permission android:name="android.permission.CAPTURE_AUDIO_OUTPUT" />
</manifest>

using Android.Widget;
using Microsoft.Azure.KeyVault;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;
using System;
using System.IO;
using System.Threading.Tasks;
using Xamarin.Essentials;
using Xamarin.Forms;
using ClientCredential = Microsoft.IdentityModel.Clients.ActiveDirectory.ClientCredential;

namespace newvideo
{
    public partial class MainPage : ContentPage
    {
        public MainPage()
        {
            InitializeComponent();
        }

    private int uploadCompleteCount { get; set; }
    private int recordedCount { get; set; }

    private async void Capture_Video(object sender, EventArgs e)
    {
        var result = await MediaPicker.CaptureVideoAsync(new MediaPickerOptions { Title = "cloudvideo" });
        if(result != null)
        {
            recordedCount++;
            var context = Android.App.Application.Context;
            var shortDuration = ToastLength.Short;
            Toast.MakeText(context,"Uploading..", shortDuration).Show();

            ////Save the video to cloud directly from incoming stream and also locally to the Android Download folder
            var localFilePath = Path.Combine("//storage//emulated//0//Download", result.FileName);
            using (Stream cloudStream = await result.OpenReadAsync())
            {
                await SaveToBlobStorage(cloudStream);
                using (FileStream localFileStream = File.OpenWrite(localFilePath))
                {   
                    cloudStream.Position = 0;
                    await cloudStream.CopyToAsync(localFileStream);
                }
            }    
        }
    }
  
   /////Place Additional Methods here
   }
}

private async Task SaveToBlobStorage(Stream stream)
{
    var context = Android.App.Application.Context;
    var longDuration = ToastLength.Long;

    string storeAccount = await AccessKeyVault("[YOUR_CONNECTIONSTRING_SECRET_NAME]");
    CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storeAccount);
    CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
    CloudBlobContainer container = blobClient.GetContainerReference("videodata");
    CloudBlockBlob blockBlob = container.GetBlockBlobReference("Video" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".mp4");
    await container.CreateIfNotExistsAsync();
    await blockBlob.UploadFromStreamAsync(stream);
    uploadCompleteCount++;
    Toast.MakeText(context, uploadCompleteCount + " of " + recordedCount + " Uploaded", longDuration).Show();
}

public static async Task<string> AccessKeyVault(string secretName)
{
    string clientId = "[YOUR_SERVICE_PRINCIPAL_CLIENTID]";
    string clientSecret = "[YOUR_SERVICE_PRINCIPAL_CLIENTSECRET]";

    KeyVaultClient kvClient = new KeyVaultClient(async (authority, resource, scope) =>
    {
        var adCredential = new ClientCredential(clientId, clientSecret);
        var authenticationContext = new AuthenticationContext(authority, null);
        return (await authenticationContext.AcquireTokenAsync(resource, adCredential)).AccessToken;
    });

    var keyvaultSecret = await kvClient.GetSecretAsync("https://[YOUR_KEYVAULT_NAME].vault.azure.net", secretName);
    return keyvaultSecret.Value;
}

using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.EventGrid.Models;
using Microsoft.Azure.WebJobs.Extensions.EventGrid;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;
using Azure.Storage.Blobs;
using Microsoft.Azure.Management.Media;
using Microsoft.Azure.Management.Media.Models;
using Microsoft.Extensions.Configuration;
using Microsoft.Rest;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Microsoft.Rest.Azure.Authentication;
using Azure.Storage.Queues;
using System.IO;
using Newtonsoft.Json;
using System.Text;

namespace EncoderCore {

public static class EncoderCore
{

    [FunctionName("FileLoader")]
    public static async void FileLoader([BlobTrigger("videodata/{name}", Connection = "AzureWebJobsStorage")] Stream content, string name, ILogger log, [Blob("videodata/{name}", FileAccess.Write,Connection = "AzureWebJobsStorage")] BlobClient blobClient)
    {   //accept common video file extensions and container formats like mkv
        if (name.ToLower().Contains(".mp4") || name.ToLower().Contains(".mkv") || name.ToLower().Contains(".mov") || name.ToLower().Contains(".webm"))
        {
            await BeginEncode(log, name, blobClient);
        }
    }

    private static async Task BeginEncode(ILogger log, string name, BlobClient blobClient)
    {
        var mediaServicesClient = await CreateMediaServicesClientAsync();

        //set encoding settings here, known as a Transform in Media Service terminology
        await GetOrCreateTransformAsync(mediaServicesClient, "[YOUR_AZURE_RESOURCE_GROUP]", "[YOUR_MEDIA_SERVICES_NAME]", "testTransform");
        log.LogInformation("transform created/found");

        //a seedAsset for setting a custom container/folder name
        Asset seedAsset = new Asset();
        seedAsset.Container = SanitiseString(name.ToLower()) + "outputcontainer";

        //create the outputAsset using a seedAsset with a custom folder name and randomised outputAsset name
        Asset outputAsset =  await mediaServicesClient.Assets.CreateOrUpdateAsync( "[YOUR_AZURE_RESOURCE_GROUP]", "[YOUR_MEDIA_SERVICES_NAME]", "myoutputasset" + $"-{Guid.NewGuid():N}", seedAsset);
        log.LogInformation("output container created");

        //use a blobClient on the newly uploaded video in the videodata folder to obtain a SAS Url with read permissions
        var blobSASURL = blobClient.GenerateSasUri(Azure.Storage.Sas.BlobSasPermissions.Read, DateTime.UtcNow.AddHours(1).ToUniversalTime());

        log.LogInformation("sas url ok");

        //use the SAS url to get the absoluteUri for the new video uploaded, and use that as the 'input asset' for the Azure Media Services Instance. Using a Stream object will create another blob 
        JobInputHttp jobInput = new JobInputHttp(files: new[] { blobSASURL.AbsoluteUri });

        //create the job output from the outputAsset
        JobOutput[] jobOutputs = { new JobOutputAsset(outputAsset.Name) };

        //start encoding in the cloud!!
        await mediaServicesClient.Jobs.CreateAsync(
        "[YOUR_AZURE_RESOURCE_GROUP]", 
        "[YOUR_MEDIA_SERVICES_NAME]",
        "testTransform",
        "job1"+ $"-{Guid.NewGuid():N}",
        new Job
        {
       		Input = jobInput,
        	Outputs = jobOutputs,
        });

        log.LogInformation("job created");
    }
    
    ////Place Additional Methods here and EnqueuMessage Function Code
	}
}

//get credentials for using with AMS
private static async Task<IAzureMediaServicesClient> CreateMediaServicesClientAsync()
{
    var credentials = await GetCredentialsAsync();

    return new AzureMediaServicesClient(credentials)
    {
    	SubscriptionId = "[YOUR_AZURE_SUBSCRIPTION_ID]",
    };
}

//the domain can be found from the AMS instance properties 
private static async Task<ServiceClientCredentials> GetCredentialsAsync()
{
    ClientCredential clientCredential = new ClientCredential("[YOUR_SERVICE_PRINCIPAL_CLIENTID]", "[YOUR_SERVICE_PRINCIPAL_CLIENTSECRET]");
    return await ApplicationTokenProvider.LoginSilentAsync("[YOUR_DOMAIN]", clientCredential, ActiveDirectoryServiceSettings.Azure);
}

private static async Task<Transform> GetOrCreateTransformAsync(
IAzureMediaServicesClient client,
string resourceGroupName,
string accountName,
string transformName)
{
    // reuse existing transform if it exists already
    Transform transform = await client.Transforms.GetAsync(resourceGroupName, accountName, transformName);

    if (transform == null)
    {
        // Settings
        TransformOutput[] output = new TransformOutput[]
        {
        new TransformOutput
        {
            Preset = new BuiltInStandardEncoderPreset()
             {
                // 1080p h264 output.
                PresetName = EncoderNamedPreset.H264SingleBitrate1080p, 
            }
        }
    };
    transform = await client.Transforms.CreateOrUpdateAsync(resourceGroupName, accountName, transformName, output);
    }

    return transform;
}

//sanitising string to have a well formatted output container name
public static string SanitiseString(string fileName)
{
    StringBuilder sb = new StringBuilder(fileName);
    sb.Replace(".mp4", "");
    sb.Replace(".mkv", "");
    sb.Replace(".webm", "");
    sb.Replace(".mov", "");
    sb.Replace("-", "");
    sb.Replace(".", "");
    sb.Replace(" ", "");
    return sb.ToString().ToLower();
}

//Additional code belonging in the EncoderCore Function App
//Root and Output are used here for deserialising the payload passed in from AMS, where we just need to get the "assetName" property
public class Output
{
	public string assetName { get; set; } 
}

public class Root
{
	public Output output { get; set; }
}

[FunctionName("EnqueueMessage")]
[return: Queue("videooutputnames", Connection = "AzureWebJobsStorage")]
public static async Task EnqueueMessage([EventGridTrigger] EventGridEvent eventGridEvent, ILogger log)
{

  var mediaServicesClient = await CreateMediaServicesClientAsync();
  //extract the assetname from the event grid Event
  var assetname = JsonConvert.DeserializeObject<Root>(eventGridEvent.Data.ToString()).output.assetName;

  Asset createdAsset = await mediaServicesClient.Assets.GetAsync("AzureLearn", "cloudencoder", assetname);
  log.LogInformation("Enqueue Message ok");
  return createdAsset.Container; //this return value is automatically written to the queue
 
}

using Azure.Storage.Queues;
using Azure.Storage.Queues.Models;
using System.Configuration;
using System;
using System.Linq;
using System.Timers;
using Topshelf;
using System.Threading.Tasks;
using System.IO;
using Azure.Storage.Blobs;
using log4net;
using log4net.Config;

namespace DeQueue
{

public class AutoDequeueService
{

private static ILog log;

private Timer _timer;

private static void Main(string[] args)
{
    HostFactory.Run(x =>
    {
        x.Service<AutoDequeueService>(s=> { 
            s.ConstructUsing(program => new AutoDequeueService());
            s.WhenStarted(program => program.Start());
            s.WhenStopped(program => program.Stop());
            });
        x.EnableServiceRecovery(r => r.RestartService(TimeSpan.FromSeconds(20)));
        x.SetServiceName("DeQueueService");
        x.SetDisplayName("DeQueue Service");
        x.SetDescription("A service for auto downloaded newly transcoded video from the cloud.");

        x.RunAsLocalSystem();
        x.StartManually();

    });
}

public AutoDequeueService()
{
	_timer = new Timer(3000) { AutoReset = true };
	_timer.Elapsed += (sender, eventArgs) => AwaitMessages();
}

public void Start() {
    string path = Directory.GetCurrentDirectory();
    //get log4net configuration from log4net.xml(shown below) when using NET5/NetCore
    XmlConfigurator.Configure(new FileInfo(Path.Combine(path, "log4net.xml")));
    log = LogManager.GetLogger("FileLogger");
    _timer.Start();
    log.Info("Service Started"); 
}

public void Stop() { _timer.Stop(); }

////Place Additional Methods here
 }
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
	<appSettings>
		<add key ="StorageConnectionString" value="[YOUR_STORAGEACCOUNT_CONNECTIONSTRING]"/>
		<add key ="QueueName" value="videooutputnames"/>
	</appSettings>
</configuration>

<?xml version="1.0" encoding="utf-8" ?>
<log4net>
	<appender name="console" type="log4net.Appender.ConsoleAppender">
		<layout type="log4net.Layout.PatternLayout">
		</layout>
	</appender>
	<appender name="FileLogger" type="log4net.Appender.RollingFileAppender">
		<file value="C:/Logs/logfile.txt" />
		<appendToFile value="true" />
		<rollingStyle value="Date" />
		<datePattern value="yyyyMMdd-HHmm" />
		<layout type="log4net.Layout.PatternLayout">
			<conversionPattern value="%date %level %message%newline" />
		</layout>
	</appender>
	<root>
		<level value="ALL" />
		<appender-ref ref="console" />
		<appender-ref ref="FileLogger" />

	</root>
</log4net>

public void AwaitMessages()
{   //stop timer to stop continuously calling into Runner
	_timer.Stop();
	Runner().Wait();
}

public static async Task Runner()
{   //connect to to the queue with connectionString via queueClient
    string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];
    string videoOutputNamesQueue = ConfigurationManager.AppSettings["QueueName"];

    QueueClientOptions queueClientOptions = new QueueClientOptions()
    {
    	MessageEncoding = QueueMessageEncoding.Base64
    };
    QueueClient queueClient = new QueueClient(connectionString, videoOutputNamesQueue, queueClientOptions);
    log.Info("Waiting for messages to arrive..");

    while (true)
    {   //get the message at the front of the queue
        QueueMessage receivedMessage = await queueClient.ReceiveMessageAsync();

        if (receivedMessage == null) continue;
        log.Info(receivedMessage.MessageText + " has been received");
        //Download
        await Download(receivedMessage.MessageText);
        //Delete queue message when done to get next message in queue
        queueClient.DeleteMessage(receivedMessage.MessageId, receivedMessage.PopReceipt);
        log.Info("Deleted Message");
    }
}

public static async Task Download(string message)
{
    try
    {
        string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"];

        var container = new BlobContainerClient(connectionString, message);

        //get the largest file in the container and download it
        var blobs = container.GetBlobs();
        var datafile = blobs.OrderByDescending(x => x.Properties.ContentLength).FirstOrDefault();
        BlobClient blobClient = container.GetBlobClient(datafile.Name);
        //save to destination folder which will be the target DLNA folder
        Stream filetarget = File.OpenWrite(@"C:\\download\\" + datafile.Name);
        log.Info("Downloading " + datafile.Name);

        await blobClient.DownloadToAsync(filetarget);
        filetarget.Close();
        log.Info("Finished Downloading  " + datafile.Name);

    }
    catch (Exception ex)
    {
        log.Error(ex.Message);
    }

}