package com.metaio.cloud.plugin.util;

import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnErrorListener;
import android.media.MediaPlayer.OnInfoListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.os.Vibrator;
import android.text.TextUtils;
import com.metaio.R.raw;
import com.metaio.cloud.plugin.MetaioCloudPlugin;
import com.metaio.cloud.plugin.data.RemoteAssetsManager;
import com.metaio.sdk.MetaioDebug;
import com.metaio.sdk.jni.MetaioWorldAlertType;
import com.metaio.sdk.jni.PathOrURL;
import java.io.File;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MetaioSoundController
  implements MediaPlayer.OnCompletionListener, MediaPlayer.OnPreparedListener, MediaPlayer.OnErrorListener, MediaPlayer.OnInfoListener
{
  private Context mContext;
  private Map<String, MediaPlayer> mMediaPlayerMap = new HashMap();
  private OnSoundCompleted mOnCompletionListener;

  public MetaioSoundController(Context paramContext, OnSoundCompleted paramOnSoundCompleted)
  {
    this.mOnCompletionListener = paramOnSoundCompleted;
    this.mContext = paramContext;
  }

  private MediaPlayer getNewMediaPlayer()
  {
    MediaPlayer localMediaPlayer = new MediaPlayer();
    localMediaPlayer.setOnCompletionListener(this);
    localMediaPlayer.setOnPreparedListener(this);
    localMediaPlayer.setOnErrorListener(this);
    localMediaPlayer.setOnInfoListener(this);
    return localMediaPlayer;
  }

  private void releaseAudio(MediaPlayer paramMediaPlayer)
  {
    Iterator localIterator = this.mMediaPlayerMap.keySet().iterator();
    while (localIterator.hasNext())
    {
      String str = (String)localIterator.next();
      if (paramMediaPlayer.equals((MediaPlayer)this.mMediaPlayerMap.get(str)))
      {
        paramMediaPlayer.stop();
        paramMediaPlayer.release();
        this.mMediaPlayerMap.remove(str);
      }
    }
  }

  public void onCompletion(MediaPlayer paramMediaPlayer)
  {
    MetaioDebug.log(3, "SoundController", "Audio track completed");
    try
    {
      Iterator localIterator = this.mMediaPlayerMap.entrySet().iterator();
      while (localIterator.hasNext())
      {
        Map.Entry localEntry = (Map.Entry)localIterator.next();
        if (paramMediaPlayer.equals(localEntry.getValue()))
        {
          String str = (String)localEntry.getKey();
          ((MediaPlayer)this.mMediaPlayerMap.get(str)).seekTo(0);
          if (this.mOnCompletionListener != null)
            this.mOnCompletionListener.onSoundCompleted(str);
        }
      }
    }
    catch (Exception localException)
    {
      MetaioDebug.printStackTrace(6, localException);
    }
  }

  public boolean onError(MediaPlayer paramMediaPlayer, int paramInt1, int paramInt2)
  {
    MetaioDebug.log(6, "MediaPlayer.onError: " + paramInt1 + ", " + paramInt2);
    return false;
  }

  public boolean onInfo(MediaPlayer paramMediaPlayer, int paramInt1, int paramInt2)
  {
    MetaioDebug.log(4, "MediaPlayer.onInfo: " + paramInt1 + ", " + paramInt2);
    return false;
  }

  public void onPrepared(MediaPlayer paramMediaPlayer)
  {
    MetaioDebug.log(3, "SoundController", "Audio track loaded, now playing...");
    paramMediaPlayer.start();
  }

  public final void pauseAudio()
  {
    Iterator localIterator = this.mMediaPlayerMap.values().iterator();
    while (localIterator.hasNext())
    {
      MediaPlayer localMediaPlayer = (MediaPlayer)localIterator.next();
      try
      {
        localMediaPlayer.pause();
      }
      catch (IllegalStateException localIllegalStateException)
      {
        MetaioDebug.log("Failed to stop audio: " + localIllegalStateException.getMessage(), localIllegalStateException);
      }
    }
  }

  public void playAlert()
  {
    MetaioDebug.log(3, "SoundController", "MetaioWorldPOIManagerCallback.playAlert ");
    if (this.mContext != null)
      try
      {
        MediaPlayer localMediaPlayer = MediaPlayer.create(this.mContext, R.raw.success);
        localMediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener()
        {
          public void onCompletion(MediaPlayer paramAnonymousMediaPlayer)
          {
            paramAnonymousMediaPlayer.release();
          }
        });
        localMediaPlayer.start();
        return;
      }
      catch (Exception localException)
      {
        throw new IllegalArgumentException("The file success.mp3 is not found under /res/raw/ folder. If you want to provide another sound, override this method or place success.mp3 on /res/raw/ folder", localException);
      }
    throw new NullPointerException("Context has not been set");
  }

  public void playAlert(MetaioWorldAlertType paramMetaioWorldAlertType)
  {
    if (paramMetaioWorldAlertType.equals(MetaioWorldAlertType.MetaioWorldAlertVibrate))
    {
      ((Vibrator)this.mContext.getSystemService("vibrator")).vibrate(300L);
      return;
    }
    if (paramMetaioWorldAlertType.equals(MetaioWorldAlertType.MetaioWorldAlertClick))
    {
      ((AudioManager)this.mContext.getSystemService("audio")).playSoundEffect(0);
      return;
    }
    playAlert();
  }

  public void playSound(String paramString, PathOrURL paramPathOrURL, File paramFile)
  {
    Object[] arrayOfObject = new Object[3];
    arrayOfObject[0] = paramString;
    arrayOfObject[1] = paramPathOrURL.asStringForLogging();
    arrayOfObject[2] = paramFile;
    MetaioDebug.log(3, "MetaioSoundController", String.format("MetaioWorldPOIManagerCallback.playSound: soundID %s url %s localpath %s", arrayOfObject));
    String str1;
    if (!TextUtils.isEmpty(paramFile.getPath()))
    {
      str1 = paramFile.getPath();
      if ((str1 != null) && (!str1.isEmpty()))
        break label249;
      if (!paramPathOrURL.isURL())
        break label152;
    }
    label152: label164: label249: for (String str2 = paramPathOrURL.asURL(); ; str2 = str1)
      try
      {
        while (true)
        {
          if (!this.mMediaPlayerMap.containsKey(paramString))
            break label164;
          ((MediaPlayer)this.mMediaPlayerMap.get(paramString)).start();
          return;
          if (paramPathOrURL.isURL())
          {
            str1 = MetaioCloudPlugin.getRemoteAssetsManager(this.mContext.getApplicationContext()).getAsset(paramPathOrURL.asURL());
            break;
          }
          str1 = paramPathOrURL.asPath().getPath();
          break;
          str2 = paramPathOrURL.asPath().getPath();
        }
        MediaPlayer localMediaPlayer = getNewMediaPlayer();
        localMediaPlayer.setDataSource(str2);
        localMediaPlayer.prepareAsync();
        this.mMediaPlayerMap.put(paramString, localMediaPlayer);
        return;
      }
      catch (Exception localException)
      {
        MetaioDebug.log(6, "Error preparing sound " + paramString + " at " + str2 + ". " + localException.getMessage());
        return;
      }
  }

  public void releaseMediaPlayers()
  {
    Iterator localIterator = this.mMediaPlayerMap.keySet().iterator();
    while (localIterator.hasNext())
    {
      String str = (String)localIterator.next();
      MediaPlayer localMediaPlayer = (MediaPlayer)this.mMediaPlayerMap.get(str);
      localMediaPlayer.stop();
      localMediaPlayer.release();
    }
    this.mMediaPlayerMap.clear();
  }

  public void releaseUnpausedMediaPlayers()
  {
    Iterator localIterator = this.mMediaPlayerMap.entrySet().iterator();
    while (localIterator.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)localIterator.next();
      MediaPlayer localMediaPlayer = (MediaPlayer)localEntry.getValue();
      if (localMediaPlayer.getCurrentPosition() <= 0)
      {
        MetaioDebug.log(4, "Releasing sound " + (String)localEntry.getKey());
        localMediaPlayer.stop();
        localMediaPlayer.release();
        localIterator.remove();
      }
    }
  }

  public final void resumeAudio()
  {
    Iterator localIterator = this.mMediaPlayerMap.values().iterator();
    while (localIterator.hasNext())
    {
      MediaPlayer localMediaPlayer = (MediaPlayer)localIterator.next();
      try
      {
        if (localMediaPlayer.getCurrentPosition() > 0)
          localMediaPlayer.start();
      }
      catch (IllegalStateException localIllegalStateException)
      {
        MetaioDebug.log("Failed to pause audio: " + localIllegalStateException.getMessage(), localIllegalStateException);
      }
    }
  }

  public void stopSound(String paramString, PathOrURL paramPathOrURL, File paramFile, boolean paramBoolean)
  {
    StringBuilder localStringBuilder = new StringBuilder().append("MetaioWorldPOIManagerCallback.stopSound: ");
    String str;
    if (paramPathOrURL == null)
      str = "<null>";
    while (true)
    {
      MetaioDebug.log(3, "MetaioSoundController", str + ", " + paramBoolean);
      MediaPlayer localMediaPlayer;
      if ((paramString != null) && (this.mMediaPlayerMap.containsKey(paramString)))
      {
        localMediaPlayer = (MediaPlayer)this.mMediaPlayerMap.get(paramString);
        if (!paramBoolean)
          break label103;
      }
      try
      {
        localMediaPlayer.pause();
        return;
        str = paramPathOrURL.asStringForLogging();
        continue;
        label103: localMediaPlayer.stop();
        localMediaPlayer.release();
        this.mMediaPlayerMap.remove(paramString);
        return;
      }
      catch (IllegalStateException localIllegalStateException)
      {
        MetaioDebug.log("Failed to stop audio: " + localIllegalStateException.getMessage(), localIllegalStateException);
      }
    }
  }

  public static abstract interface OnSoundCompleted
  {
    public abstract void onSoundCompleted(String paramString);
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.metaio.cloud.plugin.util.MetaioSoundController
 * JD-Core Version:    0.6.2
 */