[ x ] Updated libraries to the latest version and test also on version 1.4.267 which does not work as well.
[ x ] Read through the README of the project
Context description
Error occur since I changed all media playing through the service. It was working before.
Issue Description
playing a live in service throw a 403 error. Apparently not token are added.
playing a VOD works.
intentStart.putExtra(MediaPlayerService.ARG_MEDIA_IDENTIFIER, "urn:rts:video:1967124") // same usage but thow a 403 error.
Please copy the complete content of your build.gradle and any other configuration files you use below:
build.gradle:
/*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*/
// GENERATED FILE! DO NOT EDIT!
apply plugin: 'android'
buildscript {
repositories {
mavenCentral()
}
// Switch the Android Gradle plugin version requirement depending on the
// installed version of Gradle. This dependency is documented at
// http://tools.android.com/tech-docs/new-build-system/version-compatibility
// and https://issues.apache.org/jira/browse/CB-8143
if (gradle.gradleVersion >= "2.2") {
dependencies {
classpath 'com.android.tools.build:gradle:1.0.0+'
}
} else if (gradle.gradleVersion >= "2.1") {
dependencies {
classpath 'com.android.tools.build:gradle:0.14.0+'
}
} else {
dependencies {
classpath 'com.android.tools.build:gradle:0.12.0+'
}
}
}
// Allow plugins to declare Maven dependencies via build-extras.gradle.
repositories {
mavenCentral()
}
task wrapper(type: Wrapper) {
gradleVersion = '2.2.1'
}
// Configuration properties. Set these via environment variables, build-extras.gradle, or gradle.properties.
// Refer to: http://www.gradle.org/docs/current/userguide/tutorial_this_and_that.html
ext {
apply from: 'CordovaLib/cordova.gradle'
// The value for android.compileSdkVersion.
if (!project.hasProperty('cdvCompileSdkVersion')) {
cdvCompileSdkVersion = null;
}
// The value for android.buildToolsVersion.
if (!project.hasProperty('cdvBuildToolsVersion')) {
cdvBuildToolsVersion = null;
}
// Sets the versionCode to the given value.
if (!project.hasProperty('cdvVersionCode')) {
cdvVersionCode = null
}
// Sets the minSdkVersion to the given value.
if (!project.hasProperty('cdvMinSdkVersion')) {
cdvMinSdkVersion = null
}
// Whether to build architecture-specific APKs.
if (!project.hasProperty('cdvBuildMultipleApks')) {
cdvBuildMultipleApks = null
}
// .properties files to use for release signing.
if (!project.hasProperty('cdvReleaseSigningPropertiesFile')) {
cdvReleaseSigningPropertiesFile = null
}
// .properties files to use for debug signing.
if (!project.hasProperty('cdvDebugSigningPropertiesFile')) {
cdvDebugSigningPropertiesFile = null
}
// Set by build.js script.
if (!project.hasProperty('cdvBuildArch')) {
cdvBuildArch = null
}
// Plugin gradle extensions can append to this to have code run at the end.
cdvPluginPostBuildExtras = []
}
// PLUGIN GRADLE EXTENSIONS START
apply from: "cordova-plugin-crosswalk-webview/rtsinfo-xwalk.gradle"
apply from: "cordova-plugin-srg-media-player/rtsinfo-srgmediaplayer.gradle"
apply from: "urbanairship-cordova/rtsinfo-build-extras.gradle"
// PLUGIN GRADLE EXTENSIONS END
def hasBuildExtras = file('build-extras.gradle').exists()
if (hasBuildExtras) {
apply from: 'build-extras.gradle'
}
// Set property defaults after extension .gradle files.
if (ext.cdvCompileSdkVersion == null) {
ext.cdvCompileSdkVersion = privateHelpers.getProjectTarget()
}
if (ext.cdvBuildToolsVersion == null) {
ext.cdvBuildToolsVersion = privateHelpers.findLatestInstalledBuildTools()
}
if (ext.cdvDebugSigningPropertiesFile == null && file('debug-signing.properties').exists()) {
ext.cdvDebugSigningPropertiesFile = 'debug-signing.properties'
}
if (ext.cdvReleaseSigningPropertiesFile == null && file('release-signing.properties').exists()) {
ext.cdvReleaseSigningPropertiesFile = 'release-signing.properties'
}
// Cast to appropriate types.
ext.cdvBuildMultipleApks = cdvBuildMultipleApks == null ? false : cdvBuildMultipleApks.toBoolean();
ext.cdvMinSdkVersion = cdvMinSdkVersion == null ? null : Integer.parseInt('' + cdvMinSdkVersion)
ext.cdvVersionCode = cdvVersionCode == null ? null : Integer.parseInt('' + cdvVersionCode)
def computeBuildTargetName(debugBuild) {
def ret = 'assemble'
if (cdvBuildMultipleApks && cdvBuildArch) {
def arch = cdvBuildArch == 'arm' ? 'armv7' : cdvBuildArch
ret += '' + arch.toUpperCase().charAt(0) + arch.substring(1);
}
return ret + (debugBuild ? 'Debug' : 'Release')
}
// Make cdvBuild a task that depends on the debug/arch-sepecific task.
task cdvBuildDebug
cdvBuildDebug.dependsOn {
return computeBuildTargetName(true)
}
task cdvBuildRelease
cdvBuildRelease.dependsOn {
return computeBuildTargetName(false)
}
task cdvPrintProps << {
println('cdvCompileSdkVersion=' + cdvCompileSdkVersion)
println('cdvBuildToolsVersion=' + cdvBuildToolsVersion)
println('cdvVersionCode=' + cdvVersionCode)
println('cdvMinSdkVersion=' + cdvMinSdkVersion)
println('cdvBuildMultipleApks=' + cdvBuildMultipleApks)
println('cdvReleaseSigningPropertiesFile=' + cdvReleaseSigningPropertiesFile)
println('cdvDebugSigningPropertiesFile=' + cdvDebugSigningPropertiesFile)
println('cdvBuildArch=' + cdvBuildArch)
println('computedVersionCode=' + android.defaultConfig.versionCode)
android.productFlavors.each { flavor ->
println('computed' + flavor.name.capitalize() + 'VersionCode=' + flavor.versionCode)
}
}
android {
sourceSets {
main {
manifest.srcFile 'AndroidManifest.xml'
java.srcDirs = ['src']
resources.srcDirs = ['src']
aidl.srcDirs = ['src']
renderscript.srcDirs = ['src']
res.srcDirs = ['res']
assets.srcDirs = ['assets']
jniLibs.srcDirs = ['libs']
}
}
defaultConfig {
versionCode cdvVersionCode ?: Integer.parseInt("" + privateHelpers.extractIntFromManifest("versionCode") + "0")
if (cdvMinSdkVersion != null) {
minSdkVersion cdvMinSdkVersion
}
}
compileSdkVersion cdvCompileSdkVersion
buildToolsVersion cdvBuildToolsVersion
if (Boolean.valueOf(cdvBuildMultipleApks)) {
productFlavors {
armv7 {
versionCode defaultConfig.versionCode + 2
ndk {
abiFilters "armeabi-v7a", ""
}
}
x86 {
versionCode defaultConfig.versionCode + 4
ndk {
abiFilters "x86", ""
}
}
all {
ndk {
abiFilters "all", ""
}
}
}
} else if (!cdvVersionCode) {
def minSdkVersion = cdvMinSdkVersion ?: privateHelpers.extractIntFromManifest("minSdkVersion")
// Vary versionCode by the two most common API levels:
// 14 is ICS, which is the lowest API level for many apps.
// 20 is Lollipop, which is the lowest API level for the updatable system webview.
if (minSdkVersion >= 20) {
defaultConfig.versionCode += 9
} else if (minSdkVersion >= 14) {
defaultConfig.versionCode += 8
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_6
targetCompatibility JavaVersion.VERSION_1_6
}
if (cdvReleaseSigningPropertiesFile) {
signingConfigs {
release {
// These must be set or Gradle will complain (even if they are overridden).
keyAlias = ""
keyPassword = "__unset" // And these must be set to non-empty in order to have the signing step added to the task graph.
storeFile = null
storePassword = "__unset"
}
}
buildTypes {
release {
signingConfig signingConfigs.release
}
}
addSigningProps(cdvReleaseSigningPropertiesFile, signingConfigs.release)
}
if (cdvDebugSigningPropertiesFile) {
addSigningProps(cdvDebugSigningPropertiesFile, signingConfigs.debug)
}
}
dependencies {
compile fileTree(dir: 'libs', include: '*.jar')
// SUB-PROJECT DEPENDENCIES START
debugCompile project(path: "CordovaLib", configuration: "debug")
releaseCompile project(path: "CordovaLib", configuration: "release")
// SUB-PROJECT DEPENDENCIES END
}
def promptForReleaseKeyPassword() {
if (!cdvReleaseSigningPropertiesFile) {
return;
}
if ('__unset'.equals(android.signingConfigs.release.storePassword)) {
android.signingConfigs.release.storePassword = privateHelpers.promptForPassword('Enter key store password: ')
}
if ('__unset'.equals(android.signingConfigs.release.keyPassword)) {
android.signingConfigs.release.keyPassword = privateHelpers.promptForPassword('Enter key password: ');
}
}
gradle.taskGraph.whenReady { taskGraph ->
taskGraph.getAllTasks().each() { task ->
if (task.name == 'validateReleaseSigning') {
promptForReleaseKeyPassword()
}
}
}
def addSigningProps(propsFilePath, signingConfig) {
def propsFile = file(propsFilePath)
def props = new Properties()
propsFile.withReader { reader ->
props.load(reader)
}
def storeFile = new File(props.get('key.store') ?: privateHelpers.ensureValueExists(propsFilePath, props, 'storeFile'))
if (!storeFile.isAbsolute()) {
storeFile = RelativePath.parse(true, storeFile.toString()).getFile(propsFile.getParentFile())
}
if (!storeFile.exists()) {
throw new FileNotFoundException('Keystore file does not exist: ' + storeFile.getAbsolutePath())
}
signingConfig.keyAlias = props.get('key.alias') ?: privateHelpers.ensureValueExists(propsFilePath, props, 'keyAlias')
signingConfig.keyPassword = props.get('keyPassword', props.get('key.alias.password', signingConfig.keyPassword))
signingConfig.storeFile = storeFile
signingConfig.storePassword = props.get('storePassword', props.get('key.store.password', signingConfig.storePassword))
def storeType = props.get('storeType', props.get('key.store.type', ''))
if (!storeType) {
def filename = storeFile.getName().toLowerCase();
if (filename.endsWith('.p12') || filename.endsWith('.pfx')) {
storeType = 'pkcs12'
} else {
storeType = signingConfig.storeType // "jks"
}
}
signingConfig.storeType = storeType
}
for (def func : cdvPluginPostBuildExtras) {
func()
}
// This can be defined within build-extras.gradle as:
// ext.postBuildExtras = { ... code here ... }
if (hasProperty('postBuildExtras')) {
postBuildExtras()
}
SimplePlayerActivity.java
package ch.rts.cordova.srgmediaplayer;
import android.app.Fragment;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.content.res.Configuration;
import android.os.Bundle;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.support.v4.app.TaskStackBuilder;
import android.support.v4.content.LocalBroadcastManager;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.ImageView;
import android.text.TextUtils;
import ch.srg.analytics.SRGAnalytics;
import com.bumptech.glide.Glide;
import ch.srg.dataProvider.integrationlayer.IlDataProvider;
import ch.srg.dataProvider.integrationlayer.SRGUrlFactory;
import ch.srg.dataProvider.integrationlayer.dependencies.Dagger;
import ch.srg.dataProvider.integrationlayer.model.AkamaiTokenDataProvider;
import ch.srg.mediaplayer.PlayerDelegate;
import ch.srg.mediaplayer.SRGMediaPlayerController;
import ch.srg.mediaplayer.SRGMediaPlayerDataProvider;
import ch.srg.mediaplayer.SRGMediaPlayerException;
import ch.srg.mediaplayer.SRGMediaPlayerView;
import ch.srg.mediaplayer.extras.fullscreen.helper.SystemUiHelper;
import ch.srg.mediaplayer.internal.exoplayer.ExoPlayerDelegate;
import ch.srg.mediaplayer.internal.nativeplayer.NativePlayerDelegate;
import ch.srg.mediaplayer.service.MediaPlayerService;
import ch.srg.networking.HTTPConnectionFactory;
import ch.srg.dataProvider.integrationlayer.model.IlUrn;
public class SimplePlayerActivity extends AppCompatActivity implements
SRGMediaPlayerController.Listener, View.OnClickListener {
public static final String ARG_URN = "urn";
public static final String ARG_IS_PLAYING = "isplaying";
private static final String FRAGMENT_TAG = "mediaFragment";
private static final String PLAYER_TAG = "simplePlayer";
private static final String TAG = "SimplePlayerActivity";
public static final String INTENT_EXTRA_IS_PUSH = "rtsinfo_player.ispush";
public static final String SHARE_FORMAT = "/play/%s/redirect/detail/%s";
/**
* Internal action to restore from played instance (and fall back to saved urn/position when no player available).
*/
private static final String ACTION_RESTORE_FROM_SAVED_INSTANCE = "actionRestoreSavedInstance";
private SRGMediaPlayerController srgMediaPlayer;
private SRGMediaPlayerView playerView;
@Nullable
private SimplePlayerControlView simplePlayerControlView;
private ImageView mediaPlaceholderView;
private Toolbar toolbar;
private boolean landscape;
private SystemUiHelper uiHelper;
private MediaPlayerFragment mediaPlayerFragment;
private SRGMediaPlayerDataProvider dataProvider;
private IlDataProvider ilDataProvider;
private VideoErrorMessage errorMessage;
private MenuItem shareItem;
private boolean isForeground;
private boolean serviceBindingOrBound;
private MediaPlayerService playerService;
@Nullable
private String urn;
boolean isPlaying;
private String action;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (savedInstanceState != null) {
urn = savedInstanceState.getString(ARG_URN);
isPlaying = savedInstanceState.getBoolean(ARG_IS_PLAYING);
action = ACTION_RESTORE_FROM_SAVED_INSTANCE;
} else {
urn = getIntent().getStringExtra(ARG_URN);
isPlaying = getIntent().getBooleanExtra(ARG_IS_PLAYING, false);
}
setContentView(getResources().getIdentifier("activity_simple_media_player", "layout", getPackageName()));
toolbar = (Toolbar) findViewById(getResources().getIdentifier("toolbar", "id", getPackageName()));
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
getSupportActionBar().setDisplayShowTitleEnabled(false);
landscape = getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
if (landscape) {
uiHelper = new SystemUiHelper(this, SystemUiHelper.LEVEL_IMMERSIVE, SystemUiHelper.FLAG_IMMERSIVE_STICKY);
}
playerView = (SRGMediaPlayerView) findViewById(getResources().getIdentifier("demo_video_container", "id", getPackageName()));
mediaPlaceholderView = (ImageView) findViewById(getResources().getIdentifier("srg_media_placeholder", "id", getPackageName()));
View mediaControl = findViewById(getResources().getIdentifier("media_control", "id", getPackageName()));
simplePlayerControlView = (SimplePlayerControlView) mediaControl;
errorMessage = (VideoErrorMessage) findViewById(getResources().getIdentifier("error_message", "id", getPackageName()));
dataProvider = new AkamaiTokenDataProvider(null, Dagger.get(SRGUrlFactory.class), Dagger.get(HTTPConnectionFactory.class), Dagger.get(IlDataProvider.class));
ilDataProvider = Dagger.get(IlDataProvider.class);
}
public void setupPlayerNotificationPendingIntent(IlServiceMetaDataProvider serviceDataProvider) {
Intent intent = new Intent(this, SimplePlayerActivity.class);
intent.setAction(MediaPlayerService.ACTION_RESUME);
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
stackBuilder.addNextIntentWithParentStack(intent);
PendingIntent pendingIntent =
stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
serviceDataProvider.setDefaultNotificationPendingIntent(pendingIntent);
}
private void updateMeta() {
/** thumbnail for audio */
boolean noVideo = urn == null || ilDataProvider.isAudio(urn);
if (noVideo) {
String thumbnailUrl = ilDataProvider.getThumbnailUrl(urn) + "/scale/width/" + mediaPlaceholderView.getWidth();
if (!TextUtils.isEmpty(thumbnailUrl)) {
mediaPlaceholderView.setVisibility(View.VISIBLE);
Glide.with(this)
.load(thumbnailUrl)
.fitCenter()
.crossFade()
.into(mediaPlaceholderView);
} else {
mediaPlaceholderView.setVisibility(View.GONE);
}
} else {
mediaPlaceholderView.setVisibility(View.GONE);
}
}
public void playTestIdentifier(String identifier) {
try {
String SEEK_DELIMITER = "@seek:";
if (identifier.contains(SEEK_DELIMITER)) {
Long time = Long.parseLong(identifier.substring(identifier.indexOf(SEEK_DELIMITER) + SEEK_DELIMITER.length())) * 1000;
srgMediaPlayer.play(identifier, time);
} else {
/** Service audio */
playInService(identifier);
}
} catch (SRGMediaPlayerException e) {
Log.e(TAG, "play " + identifier, e);
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
MenuInflater inflater = getMenuInflater();
inflater.inflate(getResources().getIdentifier("menu_player", "menu", getPackageName()), menu);
shareItem = menu.findItem(getResources().getIdentifier("menu_item_share", "id", getPackageName()));
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int itemId = item.getItemId();
if (itemId == android.R.id.home) {
finish();
return true;
} else if (itemId == getResources().getIdentifier("menu_item_share", "id", getPackageName())) {
shareIntent();
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
String urn = getIntent().getStringExtra(ARG_URN);
if (urn != null && !urn.isEmpty() && !ilDataProvider.isLive(urn)) {
shareItem.setVisible(true);
}
return true;
}
@Override
public void onClick(View v) {
switch (v.getId()) {
}
}
@Override
public void onMediaPlayerEvent(SRGMediaPlayerController mp, SRGMediaPlayerController.Event event) {
if (mp != srgMediaPlayer) {
Log.e(TAG, "Received unexpected media player event from: " + mp);
return;
}
switch (event.type) {
case MEDIA_READY_TO_PLAY:
updateMeta();
fetchAndSendPageView();
break;
case EXTERNAL_EVENT:
break;
case OVERLAY_CONTROL_DISPLAYED:
if (uiHelper != null) {
uiHelper.show();
}
break;
case OVERLAY_CONTROL_HIDDEN:
if (uiHelper != null) {
uiHelper.hide();
}
break;
}
}
private void fetchAndSendPageView() {
String urn = getIntent().getStringExtra(ARG_URN);
if (urn != null && !urn.isEmpty()) {
String title = ilDataProvider.getTitle(urn);
String programTitle = ilDataProvider.getShowTitle(urn);
boolean isPush = getIntent().getBooleanExtra(INTENT_EXTRA_IS_PUSH, false);
Dagger.get(SRGAnalytics.class).trackPageView(title, isPush, "mediaplayer", programTitle);
} else {
//Impossible after a MEDIA_READY_TO_PLAY unless the media is actually invalid
}
}
@Override
protected void onStart() {
super.onStart();
}
@Override
protected void onResume() {
super.onResume();
isForeground = true;
playInService(getIntent().getStringExtra(ARG_URN));
updateMeta();
bindToService();
}
@Override
protected void onStop() {
isForeground = false;
if (srgMediaPlayer != null) {
srgMediaPlayer.unbindFromMediaPlayerView(playerView);
srgMediaPlayer.unregisterEventListener(this);
}
if (!ilDataProvider.isAudio(urn) && !isChangingConfigurations() && playerService != null) {
playerService.stopPlayer();
}
unbindFromService();
super.onStop();
}
private void bindToService() {
bindService(new Intent(this, MediaPlayerService.class), serviceConnection,
BIND_AUTO_CREATE | BIND_ADJUST_WITH_ACTIVITY);
serviceBindingOrBound = true;
registerAudioStatusReceiver(this);
}
private void unbindFromService() {
if (serviceBindingOrBound) {
unbindService(serviceConnection);
serviceBindingOrBound = false;
unregisterAudioStatusReceiver(this);
}
}
private ServiceConnection serviceConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
if (serviceBindingOrBound) {
playerService = ((MediaPlayerService.LocalBinder) service).getService();
onPlayerServiceConnected();
}
}
public void onServiceDisconnected(ComponentName className) {
playerService = null;
onPlayerServiceDisconnected();
}
};
public void onPlayerServiceConnected() {
if (srgMediaPlayer != null) {
srgMediaPlayer.unbindFromMediaPlayerView(playerView);
}
srgMediaPlayer =
playerService != null ? playerService.getMediaController() : null;
if (srgMediaPlayer != null) {
srgMediaPlayer.bindToMediaPlayerView(playerView);
srgMediaPlayer.registerEventListener(this);
if (simplePlayerControlView != null) {
simplePlayerControlView.attachToController(srgMediaPlayer);
}
if (errorMessage != null) {
errorMessage.attachToController(srgMediaPlayer);
}
}
}
public void onPlayerServiceDisconnected() {
playerService = null;
}
private class ServiceStatusReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Bundle bundle = intent.getBundleExtra(MediaPlayerService.ACTION_BROADCAST_STATUS_BUNDLE);
if (bundle != null) {
}
}
public void requestBroadcastStatus(Context context) {
Intent intent = new Intent(context, MediaPlayerService.class);
intent.setAction(MediaPlayerService.ACTION_BROADCAST_STATUS);
context.startService(intent);
}
}
private ServiceStatusReceiver serviceStatusReceiver;
public void registerAudioStatusReceiver(Context context) {
Log.d(TAG, "registering audio broadcast receiver");
serviceStatusReceiver = new ServiceStatusReceiver();
LocalBroadcastManager.getInstance(context).registerReceiver(serviceStatusReceiver, new IntentFilter(MediaPlayerService.ACTION_BROADCAST_STATUS));
}
public void unregisterAudioStatusReceiver(Context context) {
Log.d(TAG, "unregistering audio broadcast receiver");
if (serviceStatusReceiver != null) {
LocalBroadcastManager.getInstance(context).unregisterReceiver(serviceStatusReceiver);
serviceStatusReceiver = null;
}
}
@Override
protected void onSaveInstanceState(Bundle outState) {
outState.putString(ARG_URN, urn);
if (srgMediaPlayer != null) {
outState.putBoolean(ARG_IS_PLAYING, srgMediaPlayer.isPlaying());
action = ACTION_RESTORE_FROM_SAVED_INSTANCE;
}
super.onSaveInstanceState(outState);
}
public static class MediaPlayerFragment extends Fragment {
public SRGMediaPlayerController mediaPlayer;
public MediaPlayerFragment() {
this.setRetainInstance(true);
}
@Override
public void onDestroy() {
super.onDestroy();
mediaPlayer.release();
}
}
public void setupPlayer() {
srgMediaPlayer.setPlayerDelegateFactory(new PlayerDelegateFactory());
}
private static class PlayerDelegateFactory implements ch.srg.mediaplayer.internal.PlayerDelegateFactory {
@Override
public PlayerDelegate getDelegateForMediaIdentifier
(PlayerDelegate.OnPlayerDelegateListener srgMediaPlayer, String mediaIdentifier) {
IlDataProvider dataProvider = Dagger.get(IlDataProvider.class);
Context context = Dagger.get(Context.class);
boolean audio = dataProvider.isAudio(mediaIdentifier);
boolean live = dataProvider.isLive(mediaIdentifier);
if (ExoPlayerDelegate.isSupported()) {
if (audio) {
if (live) {
return new ExoPlayerDelegate(context, srgMediaPlayer, ExoPlayerDelegate.SourceType.EXTRACTOR);
}
} else {
return new ExoPlayerDelegate(context, srgMediaPlayer, ExoPlayerDelegate.SourceType.HLS);
}
}
return new NativePlayerDelegate(srgMediaPlayer);
}
}
private void playInService(String s) {
IlServiceMetaDataProvider ilServiceMetaDataProvider = new IlServiceMetaDataProvider(ilDataProvider, this);
setupPlayerNotificationPendingIntent(ilServiceMetaDataProvider);
MediaPlayerService.setServiceDataProvider(ilServiceMetaDataProvider);
MediaPlayerService.setPlayerDelegateFactory(new PlayerDelegateFactory());
MediaPlayerService.setDataProvider(ilDataProvider);
Intent intentStart = new Intent(this, MediaPlayerService.class);
if (isPlaying) {
action = MediaPlayerService.ACTION_RESUME;
} else {
if (ACTION_RESTORE_FROM_SAVED_INSTANCE.equals(action)) {
action = MediaPlayerService.ACTION_PAUSE;
} else {
action = MediaPlayerService.ACTION_PLAY;
}
}
intentStart.setAction(action);
intentStart.putExtra(MediaPlayerService.ARG_MEDIA_IDENTIFIER, s);
startService(intentStart);
}
public void shareIntent() {
String urn = getIntent().getStringExtra(ARG_URN);
if (urn != null && !urn.isEmpty() && !ilDataProvider.isLive(urn)) {
IlUrn ilUrn = new IlUrn(urn);
String id = ilUrn.getId();
String target = "tv";
if (ilDataProvider.isAudio(urn)) target = "radio";
String shareUrl = "http://www.rts.ch" + String.format(SHARE_FORMAT,
target, id);
String title = ilDataProvider.getTitle(urn);
Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_TEXT, title + "\n" + shareUrl);
startActivity(Intent.createChooser(intent, "Partager"));
}
}
}
New Issue Checklist
Context description
Error occur since I changed all media playing through the service. It was working before.
Issue Description
Steps to reproduce the behaviour
Complete stacktrace output
Configuration Files
Please copy the complete content of your build.gradle and any other configuration files you use below:
build.gradle:
SimplePlayerActivity.java
Environment
Device(s) name(s):
Android version(s):