public bool TryGetParam <T>(string key, out T value)
{
// try to find a parameter with matching name across the cookies, query parameters, request headers and extended properties
if (QueryParams.TryGetValue(key, out var queryParamValue))
{
value = (T)queryParamValue;
return(true);
}
if (RequestHeaders.TryGetValue(key, out var headerValue))
{
value = (T)headerValue;
return(true);
}
if (Cookies.TryGetValue(key, out var cookieValue))
{
value = (T)cookieValue;
return(true);
}
if (ExtendedProperties.TryGetValue(key, out var extendedValue))
{
value = (T)extendedValue;
return(true);
}
// the parameter doesn't exist so return null/false
value = default(T);
return(false);
}
/// <inheritdoc />
public override bool IsErrorResponse(HttpMessage message)
{
switch (message.Response.Status)
{
case 409:
// We're not considering Container/BlobAlreadyExists as errors when the request has conditional headers.
// Convenience methods like BlobContainerClient.CreateIfNotExists will cause a lot of these responses and
// we don't want them polluting AppInsights with noise. See RequestActivityPolicy for how this is applied.
RequestHeaders header = message.Request.Headers;
if (header.TryGetValue(Constants.HeaderNames.ErrorCode, out var error) &&
(error == Constants.ErrorCodes.ContainerAlreadyExists ||
error == Constants.ErrorCodes.BlobAlreadyExists))
{
var isConditional =
header.Contains(HttpHeader.Names.IfMatch) ||
header.Contains(HttpHeader.Names.IfNoneMatch) ||
header.Contains(HttpHeader.Names.IfModifiedSince) ||
header.Contains(HttpHeader.Names.IfUnmodifiedSince);
return(!isConditional);
}
break;
}
return(base.IsErrorResponse(message));
}
private string GetHeaderValue(string name)
{
string value;
RequestHeaders.TryGetValue(name, out value);
return(value);
}
public string RequestHeader(string name)
{
string[] values;
if (!RequestHeaders.TryGetValue(name, out values) ||
values == null ||
!values.Any())
{
return(null);
}
return(string.Join(",", values.ToArray()));
}
private static string GetSetContentTypeOrDefault(RequestHeaders headers)
{
string[] setContentTypeHeaders;
if (headers.TryGetValue(SET_CONTENT_TYPE_HEADER_NAME, out setContentTypeHeaders) &&
!string.IsNullOrWhiteSpace(setContentTypeHeaders[0]))
{
return(setContentTypeHeaders[0]);
}
else
{
return(DEFAULT_CONTENT_TYPE);
}
}
private void AddRequestHeader(string name, string value)
{
string[] existing;
if (!RequestHeaders.TryGetValue(name, out existing) ||
existing == null ||
existing.Length == 0)
{
RequestHeaders[name] = new[] { value };
}
else
{
RequestHeaders[name] = existing.Concat(new[] { value }).ToArray();
}
}
public override string GetKnownRequestHeader(int index)
{
string[] value;
if (RequestHeaders.TryGetValue(KnownRequestHeaders[index], out value) &&
value != null &&
value.Length != 0)
{
if (value.Length == 1)
{
return(value[0]);
}
return(string.Join(", ", value));
}
return(null);
}
public void ProduceContinue()
{
if (_responseStarted)
{
return;
}
StringValues expect;
if (_httpVersion == HttpVersionType.Http1_1 &&
RequestHeaders.TryGetValue("Expect", out expect) &&
(expect.FirstOrDefault() ?? "").Equals("100-continue", StringComparison.OrdinalIgnoreCase))
{
SocketOutput.Write(_continueBytes);
}
}
Task <Stream> IHttpUpgradeFeature.UpgradeAsync()
{
StatusCode = 101;
ReasonPhrase = "Switching Protocols";
ResponseHeaders["Connection"] = "Upgrade";
if (!ResponseHeaders.ContainsKey("Upgrade"))
{
StringValues values;
if (RequestHeaders.TryGetValue("Upgrade", out values))
{
ResponseHeaders["Upgrade"] = values;
}
}
ProduceStartAndFireOnStarting(immediate: true).GetAwaiter().GetResult();
return(Task.FromResult(DuplexStream));
}
async Task <Stream> IHttpUpgradeFeature.UpgradeAsync()
{
StatusCode = 101;
ReasonPhrase = "Switching Protocols";
ResponseHeaders["Connection"] = "Upgrade";
if (!ResponseHeaders.ContainsKey("Upgrade"))
{
StringValues values;
if (RequestHeaders.TryGetValue("Upgrade", out values))
{
ResponseHeaders["Upgrade"] = values;
}
}
await FlushAsync(default(CancellationToken));
return(DuplexStream);
}
async Task <Stream> IHttpUpgradeFeature.UpgradeAsync()
{
if (!((IHttpUpgradeFeature)this).IsUpgradableRequest)
{
throw new InvalidOperationException(CoreStrings.CannotUpgradeNonUpgradableRequest);
}
if (IsUpgraded)
{
throw new InvalidOperationException(CoreStrings.UpgradeCannotBeCalledMultipleTimes);
}
if (!ServiceContext.ConnectionManager.UpgradedConnectionCount.TryLockOne())
{
throw new InvalidOperationException(CoreStrings.UpgradedConnectionLimitReached);
}
IsUpgraded = true;
ConnectionFeatures.Get <IDecrementConcurrentConnectionCountFeature>()?.ReleaseConnection();
StatusCode = StatusCodes.Status101SwitchingProtocols;
ReasonPhrase = "Switching Protocols";
ResponseHeaders["Connection"] = "Upgrade";
if (!ResponseHeaders.ContainsKey("Upgrade"))
{
StringValues values;
if (RequestHeaders.TryGetValue("Upgrade", out values))
{
ResponseHeaders["Upgrade"] = values;
}
}
await FlushAsync(default(CancellationToken));
return(_streams.Upgrade());
}
public void ProduceContinue()
{
if (_resultStarted)
{
return;
}
string[] expect;
if (HttpVersion.Equals("HTTP/1.1") &&
RequestHeaders.TryGetValue("Expect", out expect) &&
(expect.FirstOrDefault() ?? "").Equals("100-continue", StringComparison.OrdinalIgnoreCase))
{
SocketOutput.Write(
new ArraySegment <byte>(_continueBytes, 0, _continueBytes.Length),
(error, _) =>
{
if (error != null)
{
Trace.WriteLine("ProduceContinue " + error.ToString());
}
},
null);
}
}
public virtual void Initialize()
{
if (Player != null)
{
return;
}
if (MediaSession == null)
{
throw new ArgumentNullException(nameof(MediaSession));
}
if (RequestHeaders?.Count > 0 && RequestHeaders.TryGetValue("User-Agent", out string userAgent))
{
UserAgent = userAgent;
}
else
{
UserAgent = Util.GetUserAgent(Context, "MediaManager");
}
HttpDataSourceFactory = new DefaultHttpDataSourceFactory(UserAgent);
if (RequestHeaders?.Count > 0)
{
foreach (var item in RequestHeaders)
{
HttpDataSourceFactory.DefaultRequestProperties.Set(item.Key, item.Value);
}
}
DataSourceFactory = new DefaultDataSourceFactory(Context, null, HttpDataSourceFactory);
DashChunkSourceFactory = new DefaultDashChunkSource.Factory(DataSourceFactory);
SsChunkSourceFactory = new DefaultSsChunkSource.Factory(DataSourceFactory);
BandwidthMeter = new DefaultBandwidthMeter();
TrackSelectionFactory = new AdaptiveTrackSelection.Factory(BandwidthMeter);
TrackSelector = new DefaultTrackSelector(TrackSelectionFactory);
MediaSource = new ConcatenatingMediaSource();
Player = ExoPlayerFactory.NewSimpleInstance(Context, TrackSelector);
var audioAttributes = new Com.Google.Android.Exoplayer2.Audio.AudioAttributes.Builder()
.SetUsage(C.UsageMedia)
.SetContentType(C.ContentTypeMusic)
.Build();
Player.AudioAttributes = audioAttributes;
//TODO: Use this in 2.9.0
//Player.SetAudioAttributes(audioAttributes, true);
PlayerEventListener = new PlayerEventListener()
{
OnPlayerErrorImpl = (exception) =>
{
MediaManager.OnMediaItemFailed(this, new MediaItemFailedEventArgs(MediaManager.MediaQueue.Current, exception, exception.Message));
},
OnTracksChangedImpl = (trackGroups, trackSelections) =>
{
MediaManager.MediaQueue.CurrentIndex = Player.CurrentWindowIndex;
//TODO: Update metadata of item here
}
};
Player.AddListener(PlayerEventListener);
PlaybackController = new PlaybackController();
MediaSessionConnector = new MediaSessionConnector(MediaSession, PlaybackController);
QueueNavigator = new QueueNavigator(MediaSession);
MediaSessionConnector.SetQueueNavigator(QueueNavigator);
QueueDataAdapter = new QueueDataAdapter(MediaSource);
MediaSourceFactory = new QueueEditorMediaSourceFactory();
TimelineQueueEditor = new TimelineQueueEditor(MediaSession.Controller, MediaSource, QueueDataAdapter, MediaSourceFactory);
MediaSessionConnector.SetQueueEditor(TimelineQueueEditor);
RatingCallback = new RatingCallback();
MediaSessionConnector.SetRatingCallback(RatingCallback);
PlaybackPreparer = new MediaSessionConnectorPlaybackPreparer(Player, MediaSource);
MediaSessionConnector.SetPlayer(Player, PlaybackPreparer, null);
}
