package com.metaio.sdk;

import android.annotation.TargetApi;
import android.app.Activity;
import android.content.ComponentCallbacks2;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Handler;
import android.text.TextPaint;
import android.text.TextUtils;
import android.util.Log;
import android.util.Pair;
import android.webkit.WebView;
import com.metaio.cloud.plugin.MetaioCloudPlugin;
import com.metaio.cloud.plugin.data.CalendarHelper;
import com.metaio.cloud.plugin.data.MetaioCloudDataManager;
import com.metaio.cloud.plugin.util.MetaioCloudUtils;
import com.metaio.cloud.plugin.util.MetaioSoundController;
import com.metaio.cloud.plugin.util.MetaioSoundController.OnSoundCompleted;
import com.metaio.cloud.plugin.view.POIDetailDialog;
import com.metaio.sdk.jni.ByteBuffer;
import com.metaio.sdk.jni.EAREL_MEDIA_EVENT;
import com.metaio.sdk.jni.EGEOMETRY_FOCUS_STATE;
import com.metaio.sdk.jni.EVISUAL_SEARCH_STATE;
import com.metaio.sdk.jni.IARELObject;
import com.metaio.sdk.jni.IGeometry;
import com.metaio.sdk.jni.IMetaioSDK;
import com.metaio.sdk.jni.IMetaioSDKAndroid;
import com.metaio.sdk.jni.IMetaioWorldPOIManager;
import com.metaio.sdk.jni.IMetaioWorldPOIManagerDelegate;
import com.metaio.sdk.jni.ImageStruct;
import com.metaio.sdk.jni.JunaioDataSource;
import com.metaio.sdk.jni.LLACoordinate;
import com.metaio.sdk.jni.MetaioWorldAlertType;
import com.metaio.sdk.jni.PathOrURL;
import com.metaio.sdk.jni.TrackingValuesVector;
import com.metaio.tools.SystemInfo;
import java.io.File;
import java.util.List;
import java.util.Stack;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@TargetApi(9)
public class MetaioWorldPOIManagerCallback extends IMetaioWorldPOIManagerDelegate
  implements MetaioSoundController.OnSoundCompleted
{
  public static final int REQUEST_ADD_CALENDAR_EVENT = 1006;
  public static final int REQUEST_CHANNEL_FILTER = 1000;
  public static final int REQUEST_CHANNEL_FILTER_URL = 1001;
  public static final int REQUEST_POI_CONTEXT = 1002;
  public static final int REQUEST_VIDEO_PLAY = 1005;
  public static final int REQUEST_VISUAL_SEARCH = 1003;
  public static final int REQUEST_WEBSITE = 1004;
  private Activity activity = null;
  private ARELInterpreterAndroidJava mARELInterpreter;
  private Bitmap mAnnotationBackground;
  private int mAnnotationBackgroundIndex;
  private Bitmap mBackgroundPOI;
  private Bitmap mEmptyStarImage;
  private Bitmap mFullStarImage;
  private Lock mLockDataSource;
  private MetaioSoundController mMetaioSoundController;
  public boolean mPOIDetailOpenedState;
  private IMetaioWorldPOIManager mPOIManager;
  private TextPaint mPaint;
  private TextToSpeechHelper mTextToSpeechHelper;
  private Stack<MediaEntry> mediaCallsStack;

  @TargetApi(14)
  public MetaioWorldPOIManagerCallback(Activity paramActivity)
  {
    if (paramActivity == null)
      throw new IllegalArgumentException("Activity can't be null");
    this.activity = paramActivity;
    this.mMetaioSoundController = new MetaioSoundController(paramActivity.getApplicationContext(), this);
    this.mLockDataSource = new ReentrantLock();
    this.mPaint = new TextPaint();
    this.mPaint.setFilterBitmap(true);
    this.mPaint.setAntiAlias(true);
    this.mediaCallsStack = new Stack();
    this.mARELInterpreter = new ARELInterpreterAndroidJava();
    this.mARELInterpreter.setMetaioWorldPOIManagerCallback(this);
    if (SystemInfo.isAtLeastAPI(14))
      paramActivity.registerComponentCallbacks(new ComponentCallbacks2()
      {
        public void onConfigurationChanged(Configuration paramAnonymousConfiguration)
        {
        }

        public void onLowMemory()
        {
          MetaioWorldPOIManagerCallback.this.releaseUnpausedMediaPlayers();
        }

        public void onTrimMemory(int paramAnonymousInt)
        {
          MetaioWorldPOIManagerCallback.this.releaseUnpausedMediaPlayers();
        }
      });
  }

  private void callMediaEventDelayed(final String paramString, final EAREL_MEDIA_EVENT paramEAREL_MEDIA_EVENT)
  {
    new Handler().postDelayed(new Runnable()
    {
      public void run()
      {
        MetaioCloudPlugin.log("Lifecycle", "callMediaEvent :" + paramString);
        MetaioWorldPOIManagerCallback.this.mPOIManager.callMediaEvent(paramString, paramEAREL_MEDIA_EVENT);
      }
    }
    , 2000L);
  }

  public void createCalendarEvent(long paramLong1, long paramLong2, String paramString1, String paramString2, String paramString3)
  {
    if (this.activity != null)
    {
      Intent localIntent = CalendarHelper.getAddCalendarEventIntent(this.activity, 1000L * paramLong1, 1000L * paramLong2, paramString1, paramString2, paramString3);
      this.mediaCallsStack.add(new MediaEntry("", Integer.valueOf(1006)));
      this.activity.startActivityForResult(localIntent, 1006);
      return;
    }
    throw new NullPointerException("The activity has not been set with setActivity");
  }

  public void delete()
  {
    try
    {
      if (this.mARELInterpreter != null)
      {
        this.mARELInterpreter.setMetaioWorldPOIManagerCallback(null);
        this.mARELInterpreter.release();
        this.mARELInterpreter.delete();
        this.mARELInterpreter = null;
      }
      super.delete();
      return;
    }
    finally
    {
    }
  }

  public void executeJavaScript(String paramString)
  {
    try
    {
      MetaioDebug.log("MetaioWorldPOIManagerCallback.executeJavaScript: " + paramString);
      if ((paramString == null) || (paramString.length() == 0))
      {
        MetaioDebug.log(6, "JavaScript to execute is empty");
        MetaioDebug.log(6, Log.getStackTraceString(new Exception()));
      }
      while (true)
      {
        return;
        this.mARELInterpreter.executeJavaScript(paramString);
      }
    }
    finally
    {
    }
  }

  public void flushMediaCallbackStack()
  {
    MetaioCloudPlugin.log("Lifecycle", "Flushing media stack");
    while (!this.mediaCallsStack.isEmpty())
    {
      MediaEntry localMediaEntry = (MediaEntry)this.mediaCallsStack.pop();
      String str = (String)localMediaEntry.first;
      switch (((Integer)localMediaEntry.second).intValue())
      {
      default:
        break;
      case 1004:
        if (!TextUtils.isEmpty(str))
          callMediaEventDelayed(str, EAREL_MEDIA_EVENT.EAME_WEBSITE_CLOSED);
        break;
      case 1005:
        if (!TextUtils.isEmpty(str))
        {
          callMediaEventDelayed(str, EAREL_MEDIA_EVENT.EAME_VIDEO_CLOSED);
        }
        else
        {
          MetaioDebug.log(6, "The videoID was null");
          continue;
          MetaioDebug.log(6, "The websiteID was null");
        }
        break;
      case 1006:
        callMediaEventDelayed(str, EAREL_MEDIA_EVENT.EAME_CALENDAREVENT_DONE);
      }
    }
  }

  public void initWebView(WebView paramWebView)
  {
    if (this.activity == null)
      throw new NullPointerException("You have to set an activity with setActivity first");
    if (paramWebView == null)
      throw new NullPointerException("The webview parameter can't be null");
    if (this.mARELInterpreter != null)
      this.mARELInterpreter.initWebView(paramWebView, this.activity);
  }

  public IGeometry loadPOIAnnotationForAnnotatedGeometriesGroup(IARELObject paramIARELObject, File paramFile, IMetaioSDK paramIMetaioSDK)
  {
    Bitmap[] arrayOfBitmap = new Bitmap[3];
    arrayOfBitmap[0] = this.mAnnotationBackground;
    arrayOfBitmap[1] = this.mEmptyStarImage;
    arrayOfBitmap[2] = this.mFullStarImage;
    int[] arrayOfInt = new int[1];
    arrayOfInt[0] = this.mAnnotationBackgroundIndex;
    IGeometry localIGeometry = ARELInterpreterAndroidJava.getPOIAnnotationForAnnotatedGeometriesGroup(paramIARELObject, paramFile, paramIMetaioSDK, this.mPOIManager, this.activity, this.mLockDataSource, this.mPaint, arrayOfBitmap, arrayOfInt);
    this.mAnnotationBackground = arrayOfBitmap[0];
    this.mEmptyStarImage = arrayOfBitmap[1];
    this.mFullStarImage = arrayOfBitmap[2];
    this.mAnnotationBackgroundIndex = arrayOfInt[0];
    return localIGeometry;
  }

  public IGeometry loadPOIGeometryForAnnotatedGeometriesGroup(IMetaioSDK paramIMetaioSDK)
  {
    return ARELInterpreterAndroidJava.getPOIGeometryForAnnotatedGeometriesGroup(this.activity, paramIMetaioSDK);
  }

  public final void onActivityDestroy()
  {
    releaseMediaPlayers();
    if (this.mAnnotationBackground != null)
    {
      MetaioDebug.log("Recycling bitmap");
      this.mAnnotationBackground.recycle();
      this.mAnnotationBackground = null;
    }
    if (this.mTextToSpeechHelper != null)
    {
      this.mTextToSpeechHelper.shutdown();
      this.mTextToSpeechHelper = null;
    }
  }

  public final void onActivityPause()
  {
    pauseAudio();
  }

  public void onActivityResult(int paramInt1, int paramInt2, Intent paramIntent)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.onActivityResult: " + paramInt1 + ", " + paramInt2);
    switch (paramInt1)
    {
    case 1003:
    case 1004:
    case 1005:
    case 1006:
    default:
    case 1002:
    }
    String str;
    do
    {
      do
      {
        return;
        this.mPOIDetailOpenedState = false;
        this.mPOIManager.onDetailViewClosed();
      }
      while (paramIntent == null);
      str = paramIntent.getStringExtra("url");
    }
    while (str == null);
    this.mPOIManager.processURL(str);
  }

  public final void onActivityResume()
  {
    resumeAudio();
    flushMediaCallbackStack();
  }

  public void onDidUpdatePosition(LLACoordinate paramLLACoordinate)
  {
    MetaioDebug.log("onDidUpdatePosition " + paramLLACoordinate);
  }

  public void onLoadArelComplete()
  {
    MetaioCloudPlugin.getDataSource().onLoadingARELComplete(true);
  }

  public void onNewCameraFrame(ImageStruct paramImageStruct)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.onNewCameraFrame: " + paramImageStruct.getWidth());
  }

  public void onPOIGeometryInAnnotatedGeometriesGroupChangedState(IGeometry paramIGeometry, IARELObject paramIARELObject, EGEOMETRY_FOCUS_STATE paramEGEOMETRY_FOCUS_STATE1, EGEOMETRY_FOCUS_STATE paramEGEOMETRY_FOCUS_STATE2)
  {
    ARELInterpreterAndroidJava.onPOIGeometryInAnnotatedGeometriesGroupChangedState(this.activity, paramIGeometry, paramIARELObject, paramEGEOMETRY_FOCUS_STATE1, paramEGEOMETRY_FOCUS_STATE2, this.mPOIManager);
  }

  public void onRadarPicked()
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.onRadarPicked");
  }

  public void onRadarVisibilityChanged(boolean paramBoolean)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.onRadarVisibilityChanged: " + Boolean.valueOf(paramBoolean));
  }

  public void onSDKReady()
  {
    super.onSDKReady();
  }

  protected void onSaveScreenshot(Bitmap paramBitmap, boolean paramBoolean)
  {
  }

  public void onSoundCompleted(String paramString)
  {
    this.mPOIManager.callMediaEvent(paramString, EAREL_MEDIA_EVENT.EAME_SOUND_COMPLETE);
  }

  public void onTrackingEvent(TrackingValuesVector paramTrackingValuesVector)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.onTrackingEvent");
  }

  public void onVisualSearchStatusChanged(EVISUAL_SEARCH_STATE paramEVISUAL_SEARCH_STATE)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.onVisualSearchStatusChanged: " + paramEVISUAL_SEARCH_STATE);
  }

  public void openPOIDetail(IARELObject paramIARELObject)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.openPOIDetail: " + paramIARELObject);
    MetaioCloudPlugin.getDataManager().selectPOI(paramIARELObject);
    Runnable local4 = new Runnable()
    {
      public void run()
      {
        MetaioWorldPOIManagerCallback.this.mPOIDetailOpenedState = true;
        MetaioWorldPOIManagerCallback.this.activity.startActivityForResult(this.val$intent, 1002);
      }
    };
    this.activity.runOnUiThread(local4);
  }

  public void openWebsite(String paramString1, String paramString2)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.openWebsite: " + paramString2);
    openWebsite(paramString1, paramString2, false);
  }

  public void openWebsite(String paramString1, String paramString2, boolean paramBoolean)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.openWebsite: " + paramBoolean + ", " + paramString2);
    if (!MetaioCloudPlugin.openURL(this.activity, paramString2, paramBoolean, true))
    {
      MetaioCloudUtils.showToast(this.activity, MetaioCloudPlugin.getResourceString(this.activity.getApplicationContext(), "MSGE_INVALID_URL"));
      MetaioDebug.log(6, "Error starting browser, probably invalid URL");
      return;
    }
    this.mediaCallsStack.add(new MediaEntry(paramString1, Integer.valueOf(1004)));
  }

  public final void pauseAudio()
  {
    this.mMetaioSoundController.pauseAudio();
  }

  public void playAlert()
  {
    this.mMetaioSoundController.playAlert();
  }

  public void playAlert(MetaioWorldAlertType paramMetaioWorldAlertType)
  {
    this.mMetaioSoundController.playAlert(paramMetaioWorldAlertType);
  }

  public void playSound(String paramString, PathOrURL paramPathOrURL, File paramFile)
  {
    this.mMetaioSoundController.playSound(paramString, paramPathOrURL, paramFile);
  }

  public void playVideo(final String paramString, PathOrURL paramPathOrURL)
  {
    MetaioDebug.log("Playing Video: " + paramPathOrURL.asStringForLogging());
    final Intent localIntent = new Intent("android.intent.action.VIEW");
    if (paramPathOrURL.isURL())
      localIntent.setDataAndType(Uri.parse(paramPathOrURL.asURL()), "video/*");
    while (true)
    {
      Runnable local3 = new Runnable()
      {
        public void run()
        {
          try
          {
            if (MetaioWorldPOIManagerCallback.this.activity.getPackageManager().queryIntentActivities(localIntent, 65536).size() > 0)
            {
              MetaioDebug.log("Launching default media player... ");
              MetaioWorldPOIManagerCallback.this.mediaCallsStack.add(new MetaioWorldPOIManagerCallback.MediaEntry(MetaioWorldPOIManagerCallback.this, paramString, Integer.valueOf(1005)));
              MetaioWorldPOIManagerCallback.this.activity.startActivityForResult(localIntent, 1005);
            }
            return;
          }
          catch (Exception localException)
          {
            MetaioDebug.log(6, "Error starting media player, probably invalid URL: " + localException.getMessage());
          }
        }
      };
      this.activity.runOnUiThread(local3);
      return;
      localIntent.setDataAndType(Uri.fromFile(paramPathOrURL.asPath()), "video/*");
    }
  }

  public final void processURL(String paramString)
  {
    this.mLockDataSource.lock();
    try
    {
      MetaioDebug.log(4, "ProcessURL " + String.valueOf(paramString));
      this.mPOIManager.processURL(paramString);
      return;
    }
    finally
    {
      this.mLockDataSource.unlock();
    }
  }

  public void releaseMediaPlayers()
  {
    this.mMetaioSoundController.releaseMediaPlayers();
  }

  public void releaseUnpausedMediaPlayers()
  {
    this.mMetaioSoundController.releaseUnpausedMediaPlayers();
  }

  public final void resumeAudio()
  {
    this.mMetaioSoundController.resumeAudio();
  }

  public void setMapListVisibility(boolean paramBoolean)
  {
  }

  public final void setPOIManager(IMetaioWorldPOIManager paramIMetaioWorldPOIManager)
  {
    this.mPOIManager = paramIMetaioWorldPOIManager;
  }

  public void setTorchEnabled(boolean paramBoolean)
  {
    MetaioDebug.log("MetaioWorldPOIManagerCallback.setTorchEnabled: " + String.valueOf(paramBoolean));
    if (paramBoolean)
    {
      IMetaioSDKAndroid.startTorch(this.activity);
      return;
    }
    IMetaioSDKAndroid.stopTorch(this.activity);
  }

  public void shareScreenshot(ByteBuffer paramByteBuffer, boolean paramBoolean)
  {
    byte[] arrayOfByte = paramByteBuffer.getBuffer();
    onSaveScreenshot(BitmapFactory.decodeByteArray(arrayOfByte, 0, arrayOfByte.length), paramBoolean);
  }

  public void stopSound(String paramString, PathOrURL paramPathOrURL, File paramFile, boolean paramBoolean)
  {
    this.mMetaioSoundController.stopSound(paramString, paramPathOrURL, paramFile, paramBoolean);
  }

  protected void takeScreenshot()
  {
    MetaioDebug.log("Requesting screenshot");
    this.mPOIManager.processURL("arel://scene/shareScreenshot");
  }

  public void textToSpeech(String paramString)
  {
    try
    {
      if (this.mTextToSpeechHelper == null)
        this.mTextToSpeechHelper = new TextToSpeechHelper(this.activity);
      this.mTextToSpeechHelper.speak(paramString);
      return;
    }
    finally
    {
    }
  }

  class MediaEntry extends Pair<String, Integer>
  {
    public MediaEntry(String paramInteger, Integer arg3)
    {
      super(localObject);
    }
  }
}

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