Android Youtube Player Api attività finitura e creare

Question

Abbiamo usato Youtube API per Android, ma c'è un problema con chiusura rapida e aprendo la stessa attività con player di YouTube e YouTube vista giocatore. Questo problema si verifica anche nell'applicazione di esempio, quando provo ad aprire l'attività fulscreen (senza fare clic su fullscreenbutton), quindi chiudo l'attività con il tasto backb e ancora e ancora. Arresto anomalo dell'app Yutube.

10-11 15:14:53.313: E/ActivityThread(22537): Activity com.example.myvideo.FullscreenDemoActivity has leaked ServiceConnection 
com.google.android.youtube.player.internal.r$e@46095818 that was originally bound here 

Ho provato a sovrascrivere OnStop per rilasciare il lettore ma senza risultati positivi. Per favore qualcuno aiuti.

Modifica attività schermo intero - poche differenze di linee tra originale e questo. Grazie!

import static android.view.ViewGroup.LayoutParams.MATCH_PARENT; 
import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT; 

import com.google.android.youtube.player.YouTubePlayer; 
import com.google.android.youtube.player.YouTubePlayer.PlayerStyle; 
import com.google.android.youtube.player.YouTubePlayerView; 

import android.content.Intent; 
import android.content.pm.ActivityInfo; 
import android.content.res.Configuration; 
import android.os.Build; 
import android.os.Bundle; 
import android.view.View; 
import android.view.ViewGroup; 
import android.widget.Button; 
import android.widget.CompoundButton; 
import android.widget.LinearLayout; 
import android.widget.LinearLayout.LayoutParams; 


/** 
* Sample activity showing how to properly enable custom fullscreen behavior. 
* <p> 
* This is the preferred way of handling fullscreen because the default fullscreen implementation 
* will cause re-buffering of the video. 
*/ 
    public class FullscreenDemoActivity extends YouTubeFailureRecoveryActivity implements 
    View.OnClickListener, 
    CompoundButton.OnCheckedChangeListener, 
    YouTubePlayer.OnFullscreenListener { 

    private static final int PORTRAIT_ORIENTATION = Build.VERSION.SDK_INT < 9 
     ? ActivityInfo.SCREEN_ORIENTATION_PORTRAIT 
     : ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT; 

    private LinearLayout baseLayout; 
    private YouTubePlayerView playerView; 
    private YouTubePlayer player; 
    private Button fullscreenButton; 
    private CompoundButton checkbox; 
    private View otherViews; 
    public boolean CanClose = false; 
    private boolean fullscreen; 


    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 

    try { 
    setContentView(R.layout.fullscreen_demo); 
    baseLayout = (LinearLayout) findViewById(R.id.layout); 
    playerView = (YouTubePlayerView) findViewById(R.id.player); 
    fullscreenButton = (Button) findViewById(R.id.fullscreen_button); 
    checkbox = (CompoundButton) findViewById(R.id.landscape_fullscreen_checkbox); 
    otherViews = findViewById(R.id.other_views); 

    checkbox.setOnCheckedChangeListener(this); 
    // You can use your own button to switch to fullscreen too 
    fullscreenButton.setOnClickListener(this); 

    playerView.initialize(DeveloperKey.DEVELOPER_KEY, this); 

    doLayout(); 

    } catch (Exception e) {} 

    } 

    @Override 
    public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player, 
     boolean wasRestored) { 
     try { 
    this.player = player; 

    player.setPlayerStyle(PlayerStyle.MINIMAL); 
    //player.setShowFullscreenButton(true); 
    setControlsEnabled(); 
    // Specify that we want to handle fullscreen behavior ourselves. 
    player.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CUSTOM_LAYOUT); 
    player.setOnFullscreenListener(this); 
    if (!wasRestored) { 
     player.cueVideo(MainActivity.CurrentVideo); 

    } 
    } catch (Exception e) {} 
    } 

    @Override 
    protected YouTubePlayer.Provider getYouTubePlayerProvider() { 
    return playerView; 
    } 

    @Override 
    public void onClick(View v) { 
    player.setFullscreen(!fullscreen); 
    } 

    @Override 
    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { 
    try{ 
    int controlFlags = player.getFullscreenControlFlags(); 
    if (isChecked) { 
     // If you use the FULLSCREEN_FLAG_ALWAYS_FULLSCREEN_IN_LANDSCAPE, your activity's normal UI 
     // should never be laid out in landscape mode (since the video will be fullscreen whenever the 
     // activity is in landscape orientation). Therefore you should set the activity's requested 
     // orientation to portrait. Typically you would do this in your AndroidManifest.xml, we do it 
     // programmatically here since this activity demos fullscreen behavior both with and without 
     // this flag). 
     setRequestedOrientation(PORTRAIT_ORIENTATION); 
     controlFlags |= YouTubePlayer.FULLSCREEN_FLAG_ALWAYS_FULLSCREEN_IN_LANDSCAPE; 
    } else { 
     setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR); 
     controlFlags &= ~YouTubePlayer.FULLSCREEN_FLAG_ALWAYS_FULLSCREEN_IN_LANDSCAPE; 
    } 
    player.setFullscreenControlFlags(controlFlags); } catch (Exception e) {} 
    } 

    private void doLayout() { 

    try { 
    LinearLayout.LayoutParams playerParams = 
     (LinearLayout.LayoutParams) playerView.getLayoutParams(); 
    if (fullscreen) { 
     // When in fullscreen, the visibility of all other views than the player should be set to 
     // GONE and the player should be laid out across the whole screen. 
     playerParams.width = LayoutParams.MATCH_PARENT; 
     playerParams.height = LayoutParams.MATCH_PARENT; 

     otherViews.setVisibility(View.GONE); 
    } else { 
     // This layout is up to you - this is just a simple example (vertically stacked boxes in 
     // portrait, horizontally stacked in landscape). 
     otherViews.setVisibility(View.VISIBLE); 
     ViewGroup.LayoutParams otherViewsParams = otherViews.getLayoutParams(); 
     if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) { 
     playerParams.width = otherViewsParams.width = 0; 
     playerParams.height = WRAP_CONTENT; 
     otherViewsParams.height = MATCH_PARENT; 
     playerParams.weight = 1; 
     baseLayout.setOrientation(LinearLayout.HORIZONTAL); 
     } else { 
     playerParams.width = otherViewsParams.width = MATCH_PARENT; 
     playerParams.height = WRAP_CONTENT; 
     playerParams.weight = 0; 
     otherViewsParams.height = 0; 
     baseLayout.setOrientation(LinearLayout.VERTICAL); 
     } 
     setControlsEnabled(); 
    } 

    } catch (Exception e) {} 
    } 

    private void setControlsEnabled() { 
    checkbox.setEnabled(player != null 
     && getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT); 
    fullscreenButton.setEnabled(player != null); 
    } 

    @Override 
    public void onFullscreen(boolean isFullscreen) { 
    fullscreen = isFullscreen; 
    doLayout(); 
    } 

    @Override 
    public void onConfigurationChanged(Configuration newConfig) { 
    super.onConfigurationChanged(newConfig); 
    doLayout(); 
    } 

    @Override 
    public void onStop() { 

     if (player != null){ 

      player.release(); 
      player = null; 

     } 

     super.onStop(); 

    } 
    @Override 
    public void finish() { 
     Intent data = new Intent(); 
     setResult(RESULT_OK, data); 
     super.finish(); 

    } 


} 

Answer 1

Provare a fornire l'applicazione Contextinvece del ActivityContext:

playerView.initialize(DeveloperKey.DEVELOPER_KEY, getApplicationContext()); 

Questo potrebbe eliminare la MemoryLeak si trovano ad affrontare. La ragione è quindi che il Context è poi non più legati al ciclo di vitaActivity (goduto è distrutta), ma al ciclo di vita dell'applicazione.

Se si leggono i documenti allo getApplicationContext(), si afferma che è necessario utilizzarlo solo se è necessario un Context il cui ciclo di vita è separato dall'attuale Context.