package android.support.v4.media.session;

import android.app.Activity;
import android.app.PendingIntent;
import android.content.Context;
import android.media.MediaMetadata;
import android.media.session.MediaController;
import android.media.session.MediaController.Callback;
import android.media.session.MediaController.PlaybackInfo;
import android.media.session.MediaController.TransportControls;
import android.media.session.PlaybackState;
import android.net.Uri;
import android.os.Build.VERSION;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.IBinder.DeathRecipient;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.os.ResultReceiver;
import android.support.v4.app.BundleCompat;
import android.support.v4.app.SupportActivity;
import android.support.v4.app.SupportActivity.ExtraData;
import android.support.v4.media.MediaMetadataCompat;
import android.support.v4.media.RatingCompat;
import android.text.TextUtils;
import android.util.Log;
import android.view.KeyEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

public final class MediaControllerCompat
{
  private final b a;
  private final MediaSessionCompat.Token b;
  
  public MediaControllerCompat(Context paramContext, MediaSessionCompat.Token paramToken)
    throws RemoteException
  {
    if (paramToken == null) {
      throw new IllegalArgumentException("sessionToken must not be null");
    }
    this.b = paramToken;
    if (Build.VERSION.SDK_INT >= 24)
    {
      this.a = new e(paramContext, paramToken);
      return;
    }
    if (Build.VERSION.SDK_INT >= 23)
    {
      this.a = new d(paramContext, paramToken);
      return;
    }
    if (Build.VERSION.SDK_INT >= 21)
    {
      this.a = new c(paramContext, paramToken);
      return;
    }
    this.a = new f(this.b);
  }
  
  public MediaControllerCompat(Context paramContext, MediaSessionCompat paramMediaSessionCompat)
  {
    if (paramMediaSessionCompat == null) {
      throw new IllegalArgumentException("session must not be null");
    }
    this.b = paramMediaSessionCompat.getSessionToken();
    if (Build.VERSION.SDK_INT >= 24)
    {
      this.a = new e(paramContext, paramMediaSessionCompat);
      return;
    }
    if (Build.VERSION.SDK_INT >= 23)
    {
      this.a = new d(paramContext, paramMediaSessionCompat);
      return;
    }
    if (Build.VERSION.SDK_INT >= 21)
    {
      this.a = new c(paramContext, paramMediaSessionCompat);
      return;
    }
    this.a = new f(this.b);
  }
  
  public static MediaControllerCompat getMediaController(Activity paramActivity)
  {
    if ((paramActivity instanceof SupportActivity))
    {
      paramActivity = (a)((SupportActivity)paramActivity).getExtraData(a.class);
      if (paramActivity != null) {
        return paramActivity.a;
      }
      return null;
    }
    if (Build.VERSION.SDK_INT >= 21)
    {
      Object localObject = paramActivity.getMediaController();
      if (localObject == null) {
        return null;
      }
      localObject = ((MediaController)localObject).getSessionToken();
      try
      {
        paramActivity = new MediaControllerCompat(paramActivity, MediaSessionCompat.Token.fromToken(localObject));
        return paramActivity;
      }
      catch (RemoteException paramActivity)
      {
        Log.e("MediaControllerCompat", "Dead object in getMediaController. " + paramActivity);
      }
    }
    return null;
  }
  
  public static void setMediaController(Activity paramActivity, MediaControllerCompat paramMediaControllerCompat)
  {
    if ((paramActivity instanceof SupportActivity)) {
      ((SupportActivity)paramActivity).putExtraData(new a(paramMediaControllerCompat));
    }
    if (Build.VERSION.SDK_INT >= 21)
    {
      Object localObject = null;
      if (paramMediaControllerCompat != null) {
        localObject = MediaControllerCompatApi21.a(paramActivity, paramMediaControllerCompat.getSessionToken().getToken());
      }
      paramActivity.setMediaController((MediaController)localObject);
    }
  }
  
  public final void adjustVolume(int paramInt1, int paramInt2)
  {
    this.a.b(paramInt1, paramInt2);
  }
  
  public final boolean dispatchMediaButtonEvent(KeyEvent paramKeyEvent)
  {
    if (paramKeyEvent == null) {
      throw new IllegalArgumentException("KeyEvent may not be null");
    }
    return this.a.a(paramKeyEvent);
  }
  
  public final Bundle getExtras()
  {
    return this.a.f();
  }
  
  public final long getFlags()
  {
    return this.a.h();
  }
  
  public final Object getMediaController()
  {
    return this.a.l();
  }
  
  public final MediaMetadataCompat getMetadata()
  {
    return this.a.c();
  }
  
  public final String getPackageName()
  {
    return this.a.k();
  }
  
  public final PlaybackInfo getPlaybackInfo()
  {
    return this.a.i();
  }
  
  public final PlaybackStateCompat getPlaybackState()
  {
    return this.a.b();
  }
  
  public final List<MediaSessionCompat.QueueItem> getQueue()
  {
    return this.a.d();
  }
  
  public final CharSequence getQueueTitle()
  {
    return this.a.e();
  }
  
  public final int getRatingType()
  {
    return this.a.g();
  }
  
  public final PendingIntent getSessionActivity()
  {
    return this.a.j();
  }
  
  public final MediaSessionCompat.Token getSessionToken()
  {
    return this.b;
  }
  
  public final TransportControls getTransportControls()
  {
    return this.a.a();
  }
  
  public final void registerCallback(Callback paramCallback)
  {
    registerCallback(paramCallback, null);
  }
  
  public final void registerCallback(Callback paramCallback, Handler paramHandler)
  {
    if (paramCallback == null) {
      throw new IllegalArgumentException("callback cannot be null");
    }
    Handler localHandler = paramHandler;
    if (paramHandler == null) {
      localHandler = new Handler();
    }
    this.a.a(paramCallback, localHandler);
  }
  
  public final void sendCommand(String paramString, Bundle paramBundle, ResultReceiver paramResultReceiver)
  {
    if (TextUtils.isEmpty(paramString)) {
      throw new IllegalArgumentException("command cannot be null or empty");
    }
    this.a.a(paramString, paramBundle, paramResultReceiver);
  }
  
  public final void setVolumeTo(int paramInt1, int paramInt2)
  {
    this.a.a(paramInt1, paramInt2);
  }
  
  public final void unregisterCallback(Callback paramCallback)
  {
    if (paramCallback == null) {
      throw new IllegalArgumentException("callback cannot be null");
    }
    this.a.a(paramCallback);
  }
  
  public static abstract class Callback
    implements IBinder.DeathRecipient
  {
    a a;
    boolean b;
    boolean c = false;
    private final Object d;
    
    public Callback()
    {
      if (Build.VERSION.SDK_INT >= 21)
      {
        this.d = new MediaControllerCompatApi21.a(new b());
        return;
      }
      this.d = new c();
    }
    
    public void binderDied()
    {
      onSessionDestroyed();
    }
    
    public void onAudioInfoChanged(MediaControllerCompat.PlaybackInfo paramPlaybackInfo) {}
    
    public void onExtrasChanged(Bundle paramBundle) {}
    
    public void onMetadataChanged(MediaMetadataCompat paramMediaMetadataCompat) {}
    
    public void onPlaybackStateChanged(PlaybackStateCompat paramPlaybackStateCompat) {}
    
    public void onQueueChanged(List<MediaSessionCompat.QueueItem> paramList) {}
    
    public void onQueueTitleChanged(CharSequence paramCharSequence) {}
    
    public void onSessionDestroyed() {}
    
    public void onSessionEvent(String paramString, Bundle paramBundle) {}
    
    final class a
      extends Handler
    {
      public a(Looper paramLooper)
      {
        super();
      }
      
      public final void a(int paramInt, Object paramObject, Bundle paramBundle)
      {
        paramObject = obtainMessage(paramInt, paramObject);
        ((Message)paramObject).setData(paramBundle);
        ((Message)paramObject).sendToTarget();
      }
      
      public final void handleMessage(Message paramMessage)
      {
        if (!MediaControllerCompat.Callback.this.c) {
          return;
        }
        switch (paramMessage.what)
        {
        default: 
          return;
        case 1: 
          MediaControllerCompat.Callback.this.onSessionEvent((String)paramMessage.obj, paramMessage.getData());
          return;
        case 2: 
          MediaControllerCompat.Callback.this.onPlaybackStateChanged((PlaybackStateCompat)paramMessage.obj);
          return;
        case 3: 
          MediaControllerCompat.Callback.this.onMetadataChanged((MediaMetadataCompat)paramMessage.obj);
          return;
        case 5: 
          MediaControllerCompat.Callback.this.onQueueChanged((List)paramMessage.obj);
          return;
        case 6: 
          MediaControllerCompat.Callback.this.onQueueTitleChanged((CharSequence)paramMessage.obj);
          return;
        case 7: 
          MediaControllerCompat.Callback.this.onExtrasChanged((Bundle)paramMessage.obj);
          return;
        case 4: 
          MediaControllerCompat.Callback.this.onAudioInfoChanged((MediaControllerCompat.PlaybackInfo)paramMessage.obj);
          return;
        }
        MediaControllerCompat.Callback.this.onSessionDestroyed();
      }
    }
    
    final class b
      implements MediaControllerCompatApi21.Callback
    {
      b() {}
      
      public final void onAudioInfoChanged(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5)
      {
        MediaControllerCompat.Callback.this.onAudioInfoChanged(new MediaControllerCompat.PlaybackInfo(paramInt1, paramInt2, paramInt3, paramInt4, paramInt5));
      }
      
      public final void onExtrasChanged(Bundle paramBundle)
      {
        MediaControllerCompat.Callback.this.onExtrasChanged(paramBundle);
      }
      
      public final void onMetadataChanged(Object paramObject)
      {
        MediaControllerCompat.Callback.this.onMetadataChanged(MediaMetadataCompat.fromMediaMetadata(paramObject));
      }
      
      public final void onPlaybackStateChanged(Object paramObject)
      {
        if ((!MediaControllerCompat.Callback.this.b) || (Build.VERSION.SDK_INT >= 22)) {
          MediaControllerCompat.Callback.this.onPlaybackStateChanged(PlaybackStateCompat.fromPlaybackState(paramObject));
        }
      }
      
      public final void onQueueChanged(List<?> paramList)
      {
        MediaControllerCompat.Callback.this.onQueueChanged(MediaSessionCompat.QueueItem.fromQueueItemList(paramList));
      }
      
      public final void onQueueTitleChanged(CharSequence paramCharSequence)
      {
        MediaControllerCompat.Callback.this.onQueueTitleChanged(paramCharSequence);
      }
      
      public final void onSessionDestroyed()
      {
        MediaControllerCompat.Callback.this.onSessionDestroyed();
      }
      
      public final void onSessionEvent(String paramString, Bundle paramBundle)
      {
        if ((!MediaControllerCompat.Callback.this.b) || (Build.VERSION.SDK_INT >= 23)) {
          MediaControllerCompat.Callback.this.onSessionEvent(paramString, paramBundle);
        }
      }
    }
    
    final class c
      extends IMediaControllerCallback.Stub
    {
      c() {}
      
      public final void onEvent(String paramString, Bundle paramBundle)
        throws RemoteException
      {
        MediaControllerCompat.Callback.this.a.a(1, paramString, paramBundle);
      }
      
      public final void onExtrasChanged(Bundle paramBundle)
        throws RemoteException
      {
        MediaControllerCompat.Callback.this.a.a(7, paramBundle, null);
      }
      
      public final void onMetadataChanged(MediaMetadataCompat paramMediaMetadataCompat)
        throws RemoteException
      {
        MediaControllerCompat.Callback.this.a.a(3, paramMediaMetadataCompat, null);
      }
      
      public final void onPlaybackStateChanged(PlaybackStateCompat paramPlaybackStateCompat)
        throws RemoteException
      {
        MediaControllerCompat.Callback.this.a.a(2, paramPlaybackStateCompat, null);
      }
      
      public final void onQueueChanged(List<MediaSessionCompat.QueueItem> paramList)
        throws RemoteException
      {
        MediaControllerCompat.Callback.this.a.a(5, paramList, null);
      }
      
      public final void onQueueTitleChanged(CharSequence paramCharSequence)
        throws RemoteException
      {
        MediaControllerCompat.Callback.this.a.a(6, paramCharSequence, null);
      }
      
      public final void onSessionDestroyed()
        throws RemoteException
      {
        MediaControllerCompat.Callback.this.a.a(8, null, null);
      }
      
      public final void onVolumeInfoChanged(ParcelableVolumeInfo paramParcelableVolumeInfo)
        throws RemoteException
      {
        if (paramParcelableVolumeInfo != null) {}
        for (paramParcelableVolumeInfo = new MediaControllerCompat.PlaybackInfo(paramParcelableVolumeInfo.volumeType, paramParcelableVolumeInfo.audioStream, paramParcelableVolumeInfo.controlType, paramParcelableVolumeInfo.maxVolume, paramParcelableVolumeInfo.currentVolume);; paramParcelableVolumeInfo = null)
        {
          MediaControllerCompat.Callback.this.a.a(4, paramParcelableVolumeInfo, null);
          return;
        }
      }
    }
  }
  
  public static final class PlaybackInfo
  {
    public static final int PLAYBACK_TYPE_LOCAL = 1;
    public static final int PLAYBACK_TYPE_REMOTE = 2;
    private final int a;
    private final int b;
    private final int c;
    private final int d;
    private final int e;
    
    PlaybackInfo(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5)
    {
      this.a = paramInt1;
      this.b = paramInt2;
      this.c = paramInt3;
      this.d = paramInt4;
      this.e = paramInt5;
    }
    
    public final int getAudioStream()
    {
      return this.b;
    }
    
    public final int getCurrentVolume()
    {
      return this.e;
    }
    
    public final int getMaxVolume()
    {
      return this.d;
    }
    
    public final int getPlaybackType()
    {
      return this.a;
    }
    
    public final int getVolumeControl()
    {
      return this.c;
    }
  }
  
  public static abstract class TransportControls
  {
    public abstract void fastForward();
    
    public abstract void pause();
    
    public abstract void play();
    
    public abstract void playFromMediaId(String paramString, Bundle paramBundle);
    
    public abstract void playFromSearch(String paramString, Bundle paramBundle);
    
    public abstract void playFromUri(Uri paramUri, Bundle paramBundle);
    
    public abstract void prepare();
    
    public abstract void prepareFromMediaId(String paramString, Bundle paramBundle);
    
    public abstract void prepareFromSearch(String paramString, Bundle paramBundle);
    
    public abstract void prepareFromUri(Uri paramUri, Bundle paramBundle);
    
    public abstract void rewind();
    
    public abstract void seekTo(long paramLong);
    
    public abstract void sendCustomAction(PlaybackStateCompat.CustomAction paramCustomAction, Bundle paramBundle);
    
    public abstract void sendCustomAction(String paramString, Bundle paramBundle);
    
    public abstract void setRating(RatingCompat paramRatingCompat);
    
    public abstract void skipToNext();
    
    public abstract void skipToPrevious();
    
    public abstract void skipToQueueItem(long paramLong);
    
    public abstract void stop();
  }
  
  static class a
    extends SupportActivity.ExtraData
  {
    final MediaControllerCompat a;
    
    a(MediaControllerCompat paramMediaControllerCompat)
    {
      this.a = paramMediaControllerCompat;
    }
  }
  
  static abstract interface b
  {
    public abstract MediaControllerCompat.TransportControls a();
    
    public abstract void a(int paramInt1, int paramInt2);
    
    public abstract void a(MediaControllerCompat.Callback paramCallback);
    
    public abstract void a(MediaControllerCompat.Callback paramCallback, Handler paramHandler);
    
    public abstract void a(String paramString, Bundle paramBundle, ResultReceiver paramResultReceiver);
    
    public abstract boolean a(KeyEvent paramKeyEvent);
    
    public abstract PlaybackStateCompat b();
    
    public abstract void b(int paramInt1, int paramInt2);
    
    public abstract MediaMetadataCompat c();
    
    public abstract List<MediaSessionCompat.QueueItem> d();
    
    public abstract CharSequence e();
    
    public abstract Bundle f();
    
    public abstract int g();
    
    public abstract long h();
    
    public abstract MediaControllerCompat.PlaybackInfo i();
    
    public abstract PendingIntent j();
    
    public abstract String k();
    
    public abstract Object l();
  }
  
  static class c
    implements MediaControllerCompat.b
  {
    protected final Object a;
    IMediaSession b;
    HashMap<MediaControllerCompat.Callback, a> c = new HashMap();
    List<MediaControllerCompat.Callback> d;
    
    public c(Context paramContext, MediaSessionCompat.Token paramToken)
      throws RemoteException
    {
      this.a = MediaControllerCompatApi21.a(paramContext, paramToken.getToken());
      if (this.a == null) {
        throw new RemoteException();
      }
      m();
    }
    
    public c(Context paramContext, MediaSessionCompat paramMediaSessionCompat)
    {
      this.a = MediaControllerCompatApi21.a(paramContext, paramMediaSessionCompat.getSessionToken().getToken());
      m();
    }
    
    private void m()
    {
      a("android.support.v4.media.session.command.GET_EXTRA_BINDER", null, new MediaControllerCompat.MediaControllerImplApi21.1(this, new Handler()));
    }
    
    public MediaControllerCompat.TransportControls a()
    {
      MediaController.TransportControls localTransportControls = ((MediaController)this.a).getTransportControls();
      if (localTransportControls != null) {
        return new MediaControllerCompat.g(localTransportControls);
      }
      return null;
    }
    
    public final void a(int paramInt1, int paramInt2)
    {
      ((MediaController)this.a).setVolumeTo(paramInt1, paramInt2);
    }
    
    public final void a(MediaControllerCompat.Callback paramCallback)
    {
      Object localObject1 = this.a;
      Object localObject2 = MediaControllerCompat.Callback.a(paramCallback);
      ((MediaController)localObject1).unregisterCallback((MediaController.Callback)localObject2);
      if (this.b != null) {
        try
        {
          paramCallback = (a)this.c.remove(paramCallback);
          if (paramCallback != null) {
            this.b.unregisterCallbackListener(paramCallback);
          }
          return;
        }
        catch (RemoteException paramCallback)
        {
          Log.e("MediaControllerCompat", "Dead object in unregisterCallback. " + paramCallback);
          return;
        }
      }
      if (this.d == null) {
        this.d = new ArrayList();
      }
      this.d.remove(paramCallback);
    }
    
    public final void a(MediaControllerCompat.Callback paramCallback, Handler paramHandler)
    {
      Object localObject1 = this.a;
      Object localObject2 = MediaControllerCompat.Callback.a(paramCallback);
      ((MediaController)localObject1).registerCallback((MediaController.Callback)localObject2, paramHandler);
      if (this.b != null)
      {
        MediaControllerCompat.Callback.a(paramCallback, paramHandler);
        paramHandler = new a(paramCallback);
        this.c.put(paramCallback, paramHandler);
        paramCallback.b = true;
        try
        {
          this.b.registerCallbackListener(paramHandler);
          return;
        }
        catch (RemoteException paramCallback)
        {
          Log.e("MediaControllerCompat", "Dead object in registerCallback. " + paramCallback);
          return;
        }
      }
      if (this.d == null) {
        this.d = new ArrayList();
      }
      MediaControllerCompat.Callback.a(paramCallback, paramHandler);
      this.d.add(paramCallback);
    }
    
    public final void a(String paramString, Bundle paramBundle, ResultReceiver paramResultReceiver)
    {
      ((MediaController)this.a).sendCommand(paramString, paramBundle, paramResultReceiver);
    }
    
    public final boolean a(KeyEvent paramKeyEvent)
    {
      return ((MediaController)this.a).dispatchMediaButtonEvent(paramKeyEvent);
    }
    
    public final PlaybackStateCompat b()
    {
      if ((Build.VERSION.SDK_INT < 22) && (this.b != null)) {
        try
        {
          PlaybackStateCompat localPlaybackStateCompat = this.b.getPlaybackState();
          return localPlaybackStateCompat;
        }
        catch (RemoteException localRemoteException)
        {
          Log.e("MediaControllerCompat", "Dead object in getPlaybackState. " + localRemoteException);
        }
      }
      PlaybackState localPlaybackState = ((MediaController)this.a).getPlaybackState();
      if (localPlaybackState != null) {
        return PlaybackStateCompat.fromPlaybackState(localPlaybackState);
      }
      return null;
    }
    
    public final void b(int paramInt1, int paramInt2)
    {
      ((MediaController)this.a).adjustVolume(paramInt1, paramInt2);
    }
    
    public final MediaMetadataCompat c()
    {
      MediaMetadata localMediaMetadata = ((MediaController)this.a).getMetadata();
      if (localMediaMetadata != null) {
        return MediaMetadataCompat.fromMediaMetadata(localMediaMetadata);
      }
      return null;
    }
    
    public final List<MediaSessionCompat.QueueItem> d()
    {
      Object localObject = ((MediaController)this.a).getQueue();
      if (localObject == null) {}
      for (localObject = null; localObject != null; localObject = new ArrayList((Collection)localObject)) {
        return MediaSessionCompat.QueueItem.fromQueueItemList((List)localObject);
      }
      return null;
    }
    
    public final CharSequence e()
    {
      return ((MediaController)this.a).getQueueTitle();
    }
    
    public final Bundle f()
    {
      return ((MediaController)this.a).getExtras();
    }
    
    public final int g()
    {
      if ((Build.VERSION.SDK_INT < 22) && (this.b != null)) {
        try
        {
          int i = this.b.getRatingType();
          return i;
        }
        catch (RemoteException localRemoteException)
        {
          Log.e("MediaControllerCompat", "Dead object in getRatingType. " + localRemoteException);
        }
      }
      return ((MediaController)this.a).getRatingType();
    }
    
    public final long h()
    {
      return ((MediaController)this.a).getFlags();
    }
    
    public final MediaControllerCompat.PlaybackInfo i()
    {
      MediaController.PlaybackInfo localPlaybackInfo = ((MediaController)this.a).getPlaybackInfo();
      if (localPlaybackInfo != null) {
        return new MediaControllerCompat.PlaybackInfo(MediaControllerCompatApi21.PlaybackInfo.getPlaybackType(localPlaybackInfo), MediaControllerCompatApi21.PlaybackInfo.getLegacyAudioStream(localPlaybackInfo), MediaControllerCompatApi21.PlaybackInfo.getVolumeControl(localPlaybackInfo), MediaControllerCompatApi21.PlaybackInfo.getMaxVolume(localPlaybackInfo), MediaControllerCompatApi21.PlaybackInfo.getCurrentVolume(localPlaybackInfo));
      }
      return null;
    }
    
    public final PendingIntent j()
    {
      return ((MediaController)this.a).getSessionActivity();
    }
    
    public final String k()
    {
      return ((MediaController)this.a).getPackageName();
    }
    
    public final Object l()
    {
      return this.a;
    }
    
    final class a
      extends IMediaControllerCallback.Stub
    {
      private MediaControllerCompat.Callback b;
      
      a(MediaControllerCompat.Callback paramCallback)
      {
        this.b = paramCallback;
      }
      
      public final void onEvent(final String paramString, final Bundle paramBundle)
        throws RemoteException
      {
        this.b.a.post(new Runnable()
        {
          public final void run()
          {
            MediaControllerCompat.c.a.a(MediaControllerCompat.c.a.this).onSessionEvent(paramString, paramBundle);
          }
        });
      }
      
      public final void onExtrasChanged(Bundle paramBundle)
        throws RemoteException
      {
        throw new AssertionError();
      }
      
      public final void onMetadataChanged(MediaMetadataCompat paramMediaMetadataCompat)
        throws RemoteException
      {
        throw new AssertionError();
      }
      
      public final void onPlaybackStateChanged(final PlaybackStateCompat paramPlaybackStateCompat)
        throws RemoteException
      {
        this.b.a.post(new Runnable()
        {
          public final void run()
          {
            MediaControllerCompat.c.a.a(MediaControllerCompat.c.a.this).onPlaybackStateChanged(paramPlaybackStateCompat);
          }
        });
      }
      
      public final void onQueueChanged(List<MediaSessionCompat.QueueItem> paramList)
        throws RemoteException
      {
        throw new AssertionError();
      }
      
      public final void onQueueTitleChanged(CharSequence paramCharSequence)
        throws RemoteException
      {
        throw new AssertionError();
      }
      
      public final void onSessionDestroyed()
        throws RemoteException
      {
        throw new AssertionError();
      }
      
      public final void onVolumeInfoChanged(ParcelableVolumeInfo paramParcelableVolumeInfo)
        throws RemoteException
      {
        throw new AssertionError();
      }
    }
  }
  
  static class d
    extends MediaControllerCompat.c
  {
    public d(Context paramContext, MediaSessionCompat.Token paramToken)
      throws RemoteException
    {
      super(paramToken);
    }
    
    public d(Context paramContext, MediaSessionCompat paramMediaSessionCompat)
    {
      super(paramMediaSessionCompat);
    }
    
    public MediaControllerCompat.TransportControls a()
    {
      MediaController.TransportControls localTransportControls = ((MediaController)this.a).getTransportControls();
      if (localTransportControls != null) {
        return new MediaControllerCompat.h(localTransportControls);
      }
      return null;
    }
  }
  
  static final class e
    extends MediaControllerCompat.d
  {
    public e(Context paramContext, MediaSessionCompat.Token paramToken)
      throws RemoteException
    {
      super(paramToken);
    }
    
    public e(Context paramContext, MediaSessionCompat paramMediaSessionCompat)
    {
      super(paramMediaSessionCompat);
    }
    
    public final MediaControllerCompat.TransportControls a()
    {
      MediaController.TransportControls localTransportControls = ((MediaController)this.a).getTransportControls();
      if (localTransportControls != null) {
        return new MediaControllerCompat.i(localTransportControls);
      }
      return null;
    }
  }
  
  static final class f
    implements MediaControllerCompat.b
  {
    private MediaSessionCompat.Token a;
    private IMediaSession b;
    private MediaControllerCompat.TransportControls c;
    
    public f(MediaSessionCompat.Token paramToken)
    {
      this.a = paramToken;
      this.b = IMediaSession.Stub.asInterface((IBinder)paramToken.getToken());
    }
    
    public final MediaControllerCompat.TransportControls a()
    {
      if (this.c == null) {
        this.c = new MediaControllerCompat.j(this.b);
      }
      return this.c;
    }
    
    public final void a(int paramInt1, int paramInt2)
    {
      try
      {
        this.b.setVolumeTo(paramInt1, paramInt2, null);
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in setVolumeTo. " + localRemoteException);
      }
    }
    
    public final void a(MediaControllerCompat.Callback paramCallback)
    {
      if (paramCallback == null) {
        throw new IllegalArgumentException("callback may not be null.");
      }
      try
      {
        this.b.unregisterCallbackListener((IMediaControllerCallback)MediaControllerCompat.Callback.a(paramCallback));
        this.b.asBinder().unlinkToDeath(paramCallback, 0);
        paramCallback.c = false;
        return;
      }
      catch (RemoteException paramCallback)
      {
        Log.e("MediaControllerCompat", "Dead object in unregisterCallback. " + paramCallback);
      }
    }
    
    public final void a(MediaControllerCompat.Callback paramCallback, Handler paramHandler)
    {
      if (paramCallback == null) {
        throw new IllegalArgumentException("callback may not be null.");
      }
      try
      {
        this.b.asBinder().linkToDeath(paramCallback, 0);
        this.b.registerCallbackListener((IMediaControllerCallback)MediaControllerCompat.Callback.a(paramCallback));
        MediaControllerCompat.Callback.a(paramCallback, paramHandler);
        paramCallback.c = true;
        return;
      }
      catch (RemoteException paramHandler)
      {
        Log.e("MediaControllerCompat", "Dead object in registerCallback. " + paramHandler);
        paramCallback.onSessionDestroyed();
      }
    }
    
    public final void a(String paramString, Bundle paramBundle, ResultReceiver paramResultReceiver)
    {
      try
      {
        this.b.sendCommand(paramString, paramBundle, new MediaSessionCompat.ResultReceiverWrapper(paramResultReceiver));
        return;
      }
      catch (RemoteException paramString)
      {
        Log.e("MediaControllerCompat", "Dead object in sendCommand. " + paramString);
      }
    }
    
    public final boolean a(KeyEvent paramKeyEvent)
    {
      if (paramKeyEvent == null) {
        throw new IllegalArgumentException("event may not be null.");
      }
      try
      {
        this.b.sendMediaButton(paramKeyEvent);
        return false;
      }
      catch (RemoteException paramKeyEvent)
      {
        for (;;)
        {
          Log.e("MediaControllerCompat", "Dead object in dispatchMediaButtonEvent. " + paramKeyEvent);
        }
      }
    }
    
    public final PlaybackStateCompat b()
    {
      try
      {
        PlaybackStateCompat localPlaybackStateCompat = this.b.getPlaybackState();
        return localPlaybackStateCompat;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getPlaybackState. " + localRemoteException);
      }
      return null;
    }
    
    public final void b(int paramInt1, int paramInt2)
    {
      try
      {
        this.b.adjustVolume(paramInt1, paramInt2, null);
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in adjustVolume. " + localRemoteException);
      }
    }
    
    public final MediaMetadataCompat c()
    {
      try
      {
        MediaMetadataCompat localMediaMetadataCompat = this.b.getMetadata();
        return localMediaMetadataCompat;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getMetadata. " + localRemoteException);
      }
      return null;
    }
    
    public final List<MediaSessionCompat.QueueItem> d()
    {
      try
      {
        List localList = this.b.getQueue();
        return localList;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getQueue. " + localRemoteException);
      }
      return null;
    }
    
    public final CharSequence e()
    {
      try
      {
        CharSequence localCharSequence = this.b.getQueueTitle();
        return localCharSequence;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getQueueTitle. " + localRemoteException);
      }
      return null;
    }
    
    public final Bundle f()
    {
      try
      {
        Bundle localBundle = this.b.getExtras();
        return localBundle;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getExtras. " + localRemoteException);
      }
      return null;
    }
    
    public final int g()
    {
      try
      {
        int i = this.b.getRatingType();
        return i;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getRatingType. " + localRemoteException);
      }
      return 0;
    }
    
    public final long h()
    {
      try
      {
        long l = this.b.getFlags();
        return l;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getFlags. " + localRemoteException);
      }
      return 0L;
    }
    
    public final MediaControllerCompat.PlaybackInfo i()
    {
      try
      {
        Object localObject = this.b.getVolumeAttributes();
        localObject = new MediaControllerCompat.PlaybackInfo(((ParcelableVolumeInfo)localObject).volumeType, ((ParcelableVolumeInfo)localObject).audioStream, ((ParcelableVolumeInfo)localObject).controlType, ((ParcelableVolumeInfo)localObject).maxVolume, ((ParcelableVolumeInfo)localObject).currentVolume);
        return (MediaControllerCompat.PlaybackInfo)localObject;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getPlaybackInfo. " + localRemoteException);
      }
      return null;
    }
    
    public final PendingIntent j()
    {
      try
      {
        PendingIntent localPendingIntent = this.b.getLaunchPendingIntent();
        return localPendingIntent;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getSessionActivity. " + localRemoteException);
      }
      return null;
    }
    
    public final String k()
    {
      try
      {
        String str = this.b.getPackageName();
        return str;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in getPackageName. " + localRemoteException);
      }
      return null;
    }
    
    public final Object l()
    {
      return null;
    }
  }
  
  static class g
    extends MediaControllerCompat.TransportControls
  {
    protected final Object a;
    
    public g(Object paramObject)
    {
      this.a = paramObject;
    }
    
    public void fastForward()
    {
      MediaControllerCompatApi21.TransportControls.fastForward(this.a);
    }
    
    public void pause()
    {
      MediaControllerCompatApi21.TransportControls.pause(this.a);
    }
    
    public void play()
    {
      MediaControllerCompatApi21.TransportControls.play(this.a);
    }
    
    public void playFromMediaId(String paramString, Bundle paramBundle)
    {
      MediaControllerCompatApi21.TransportControls.playFromMediaId(this.a, paramString, paramBundle);
    }
    
    public void playFromSearch(String paramString, Bundle paramBundle)
    {
      MediaControllerCompatApi21.TransportControls.playFromSearch(this.a, paramString, paramBundle);
    }
    
    public void playFromUri(Uri paramUri, Bundle paramBundle)
    {
      if ((paramUri == null) || (Uri.EMPTY.equals(paramUri))) {
        throw new IllegalArgumentException("You must specify a non-empty Uri for playFromUri.");
      }
      Bundle localBundle = new Bundle();
      localBundle.putParcelable("android.support.v4.media.session.action.ARGUMENT_URI", paramUri);
      localBundle.putParcelable("android.support.v4.media.session.action.ARGUMENT_EXTRAS", paramBundle);
      sendCustomAction("android.support.v4.media.session.action.PLAY_FROM_URI", localBundle);
    }
    
    public void prepare()
    {
      sendCustomAction("android.support.v4.media.session.action.PREPARE", null);
    }
    
    public void prepareFromMediaId(String paramString, Bundle paramBundle)
    {
      Bundle localBundle = new Bundle();
      localBundle.putString("android.support.v4.media.session.action.ARGUMENT_MEDIA_ID", paramString);
      localBundle.putBundle("android.support.v4.media.session.action.ARGUMENT_EXTRAS", paramBundle);
      sendCustomAction("android.support.v4.media.session.action.PREPARE_FROM_MEDIA_ID", localBundle);
    }
    
    public void prepareFromSearch(String paramString, Bundle paramBundle)
    {
      Bundle localBundle = new Bundle();
      localBundle.putString("android.support.v4.media.session.action.ARGUMENT_QUERY", paramString);
      localBundle.putBundle("android.support.v4.media.session.action.ARGUMENT_EXTRAS", paramBundle);
      sendCustomAction("android.support.v4.media.session.action.PREPARE_FROM_SEARCH", localBundle);
    }
    
    public void prepareFromUri(Uri paramUri, Bundle paramBundle)
    {
      Bundle localBundle = new Bundle();
      localBundle.putParcelable("android.support.v4.media.session.action.ARGUMENT_URI", paramUri);
      localBundle.putBundle("android.support.v4.media.session.action.ARGUMENT_EXTRAS", paramBundle);
      sendCustomAction("android.support.v4.media.session.action.PREPARE_FROM_URI", localBundle);
    }
    
    public void rewind()
    {
      MediaControllerCompatApi21.TransportControls.rewind(this.a);
    }
    
    public void seekTo(long paramLong)
    {
      MediaControllerCompatApi21.TransportControls.seekTo(this.a, paramLong);
    }
    
    public void sendCustomAction(PlaybackStateCompat.CustomAction paramCustomAction, Bundle paramBundle)
    {
      MediaControllerCompatApi21.TransportControls.sendCustomAction(this.a, paramCustomAction.getAction(), paramBundle);
    }
    
    public void sendCustomAction(String paramString, Bundle paramBundle)
    {
      MediaControllerCompatApi21.TransportControls.sendCustomAction(this.a, paramString, paramBundle);
    }
    
    public void setRating(RatingCompat paramRatingCompat)
    {
      Object localObject = this.a;
      if (paramRatingCompat != null) {}
      for (paramRatingCompat = paramRatingCompat.getRating();; paramRatingCompat = null)
      {
        MediaControllerCompatApi21.TransportControls.setRating(localObject, paramRatingCompat);
        return;
      }
    }
    
    public void skipToNext()
    {
      MediaControllerCompatApi21.TransportControls.skipToNext(this.a);
    }
    
    public void skipToPrevious()
    {
      MediaControllerCompatApi21.TransportControls.skipToPrevious(this.a);
    }
    
    public void skipToQueueItem(long paramLong)
    {
      MediaControllerCompatApi21.TransportControls.skipToQueueItem(this.a, paramLong);
    }
    
    public void stop()
    {
      MediaControllerCompatApi21.TransportControls.stop(this.a);
    }
  }
  
  static class h
    extends MediaControllerCompat.g
  {
    public h(Object paramObject)
    {
      super();
    }
    
    public void playFromUri(Uri paramUri, Bundle paramBundle)
    {
      MediaControllerCompatApi23.TransportControls.playFromUri(this.a, paramUri, paramBundle);
    }
  }
  
  static final class i
    extends MediaControllerCompat.h
  {
    public i(Object paramObject)
    {
      super();
    }
    
    public final void prepare()
    {
      MediaControllerCompatApi24.TransportControls.prepare(this.a);
    }
    
    public final void prepareFromMediaId(String paramString, Bundle paramBundle)
    {
      MediaControllerCompatApi24.TransportControls.prepareFromMediaId(this.a, paramString, paramBundle);
    }
    
    public final void prepareFromSearch(String paramString, Bundle paramBundle)
    {
      MediaControllerCompatApi24.TransportControls.prepareFromSearch(this.a, paramString, paramBundle);
    }
    
    public final void prepareFromUri(Uri paramUri, Bundle paramBundle)
    {
      MediaControllerCompatApi24.TransportControls.prepareFromUri(this.a, paramUri, paramBundle);
    }
  }
  
  static final class j
    extends MediaControllerCompat.TransportControls
  {
    private IMediaSession a;
    
    public j(IMediaSession paramIMediaSession)
    {
      this.a = paramIMediaSession;
    }
    
    public final void fastForward()
    {
      try
      {
        this.a.fastForward();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in fastForward. " + localRemoteException);
      }
    }
    
    public final void pause()
    {
      try
      {
        this.a.pause();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in pause. " + localRemoteException);
      }
    }
    
    public final void play()
    {
      try
      {
        this.a.play();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in play. " + localRemoteException);
      }
    }
    
    public final void playFromMediaId(String paramString, Bundle paramBundle)
    {
      try
      {
        this.a.playFromMediaId(paramString, paramBundle);
        return;
      }
      catch (RemoteException paramString)
      {
        Log.e("MediaControllerCompat", "Dead object in playFromMediaId. " + paramString);
      }
    }
    
    public final void playFromSearch(String paramString, Bundle paramBundle)
    {
      try
      {
        this.a.playFromSearch(paramString, paramBundle);
        return;
      }
      catch (RemoteException paramString)
      {
        Log.e("MediaControllerCompat", "Dead object in playFromSearch. " + paramString);
      }
    }
    
    public final void playFromUri(Uri paramUri, Bundle paramBundle)
    {
      try
      {
        this.a.playFromUri(paramUri, paramBundle);
        return;
      }
      catch (RemoteException paramUri)
      {
        Log.e("MediaControllerCompat", "Dead object in playFromUri. " + paramUri);
      }
    }
    
    public final void prepare()
    {
      try
      {
        this.a.prepare();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in prepare. " + localRemoteException);
      }
    }
    
    public final void prepareFromMediaId(String paramString, Bundle paramBundle)
    {
      try
      {
        this.a.prepareFromMediaId(paramString, paramBundle);
        return;
      }
      catch (RemoteException paramString)
      {
        Log.e("MediaControllerCompat", "Dead object in prepareFromMediaId. " + paramString);
      }
    }
    
    public final void prepareFromSearch(String paramString, Bundle paramBundle)
    {
      try
      {
        this.a.prepareFromSearch(paramString, paramBundle);
        return;
      }
      catch (RemoteException paramString)
      {
        Log.e("MediaControllerCompat", "Dead object in prepareFromSearch. " + paramString);
      }
    }
    
    public final void prepareFromUri(Uri paramUri, Bundle paramBundle)
    {
      try
      {
        this.a.prepareFromUri(paramUri, paramBundle);
        return;
      }
      catch (RemoteException paramUri)
      {
        Log.e("MediaControllerCompat", "Dead object in prepareFromUri. " + paramUri);
      }
    }
    
    public final void rewind()
    {
      try
      {
        this.a.rewind();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in rewind. " + localRemoteException);
      }
    }
    
    public final void seekTo(long paramLong)
    {
      try
      {
        this.a.seekTo(paramLong);
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in seekTo. " + localRemoteException);
      }
    }
    
    public final void sendCustomAction(PlaybackStateCompat.CustomAction paramCustomAction, Bundle paramBundle)
    {
      sendCustomAction(paramCustomAction.getAction(), paramBundle);
    }
    
    public final void sendCustomAction(String paramString, Bundle paramBundle)
    {
      try
      {
        this.a.sendCustomAction(paramString, paramBundle);
        return;
      }
      catch (RemoteException paramString)
      {
        Log.e("MediaControllerCompat", "Dead object in sendCustomAction. " + paramString);
      }
    }
    
    public final void setRating(RatingCompat paramRatingCompat)
    {
      try
      {
        this.a.rate(paramRatingCompat);
        return;
      }
      catch (RemoteException paramRatingCompat)
      {
        Log.e("MediaControllerCompat", "Dead object in setRating. " + paramRatingCompat);
      }
    }
    
    public final void skipToNext()
    {
      try
      {
        this.a.next();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in skipToNext. " + localRemoteException);
      }
    }
    
    public final void skipToPrevious()
    {
      try
      {
        this.a.previous();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in skipToPrevious. " + localRemoteException);
      }
    }
    
    public final void skipToQueueItem(long paramLong)
    {
      try
      {
        this.a.skipToQueueItem(paramLong);
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in skipToQueueItem. " + localRemoteException);
      }
    }
    
    public final void stop()
    {
      try
      {
        this.a.stop();
        return;
      }
      catch (RemoteException localRemoteException)
      {
        Log.e("MediaControllerCompat", "Dead object in stop. " + localRemoteException);
      }
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/v4/media/session/MediaControllerCompat.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */