package com.metaio.cloud.plugin.util;

import android.app.Activity;
import android.app.AlertDialog.Builder;
import android.content.ContentResolver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.media.MediaScannerConnection;
import android.media.MediaScannerConnection.OnScanCompletedListener;
import android.net.Uri;
import android.os.Build;
import android.os.Build.VERSION;
import android.os.Environment;
import android.provider.MediaStore.Images.Media;
import android.provider.Settings.Secure;
import android.text.TextUtils;
import android.util.Log;
import android.widget.Toast;
import com.metaio.cloud.plugin.MetaioCloudPlugin;
import com.metaio.sdk.MetaioDebug;
import com.metaio.sdk.jni.LLACoordinate;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Enumeration;
import java.util.List;
import java.util.Locale;
import java.util.UUID;
import java.util.Vector;

public class MetaioCloudUtils
{
  public static final double FEET_PER_METER = 3.28084D;
  public static final int FEET_PER_MILE = 5280;
  private static String imei = "";
  private static String userAgent = "com.metaio.junaio/6.0 ";

  private static String generateNameBasedOnTimestamp(String paramString)
  {
    Calendar localCalendar = Calendar.getInstance();
    String str = "" + localCalendar.get(2) + localCalendar.get(5) + localCalendar.get(1) + localCalendar.get(11) + localCalendar.get(12) + localCalendar.get(13);
    return paramString + "-" + str + ".jpg";
  }

  public static double getBearing(LLACoordinate paramLLACoordinate1, LLACoordinate paramLLACoordinate2)
  {
    double d1 = paramLLACoordinate1.getLatitude();
    double d2 = paramLLACoordinate1.getLongitude();
    double d3 = paramLLACoordinate2.getLatitude();
    double d4 = Math.toRadians(paramLLACoordinate2.getLongitude() - d2);
    return (360.0D + Math.toDegrees(Math.atan2(Math.sin(d4) * Math.cos(d3), Math.cos(d1) * Math.sin(d3) - Math.sin(d1) * Math.cos(d3) * Math.cos(d4)))) % 360.0D;
  }

  public static String getDCIMPath()
  {
    try
    {
      File localFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "junaio");
      localFile.mkdirs();
      String str = localFile.getAbsolutePath();
      return str;
    }
    catch (Exception localException)
    {
    }
    return null;
  }

  public static double getDistanceBetweenTwoCoordinates(LLACoordinate paramLLACoordinate1, LLACoordinate paramLLACoordinate2)
  {
    double d1 = paramLLACoordinate1.getLatitude();
    double d2 = paramLLACoordinate1.getLongitude();
    double d3 = paramLLACoordinate2.getLatitude();
    double d4 = paramLLACoordinate2.getLongitude();
    double d5 = Math.toRadians(d3 - d1);
    double d6 = Math.toRadians(d4 - d2);
    double d7 = Math.toRadians(d1);
    double d8 = Math.toRadians(d3);
    double d9 = Math.sin(d5 / 2.0D) * Math.sin(d5 / 2.0D) + Math.sin(d6 / 2.0D) * Math.sin(d6 / 2.0D) * Math.cos(d7) * Math.cos(d8);
    return 2.0D * Math.atan2(Math.sqrt(d9), Math.sqrt(1.0D - d9)) * 6371000;
  }

  public static String getFileName(String paramString)
  {
    try
    {
      String[] arrayOfString = paramString.split(".*/|\\?");
      int i = arrayOfString.length;
      String str = null;
      if (i > 0)
        str = arrayOfString[(-1 + arrayOfString.length)];
      return str;
    }
    catch (Exception localException)
    {
      MetaioCloudPlugin.log(6, "Error extracting filename from URL: " + localException.getMessage());
      Log.e("metaio", "getFileName", localException);
    }
    return null;
  }

  public static String getPicturesPath()
  {
    while (true)
    {
      try
      {
        File localFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES), "metaio");
        if (!localFile.mkdirs())
          if (localFile.isDirectory())
          {
            break label98;
            if (i == 0)
              localFile = new File(Environment.getExternalStorageDirectory(), "Pictures");
            if (localFile.mkdirs())
              break label103;
            boolean bool = localFile.isDirectory();
            j = 0;
            if (bool)
              break label103;
            if (j == 0)
              localFile = Environment.getDataDirectory();
            String str = localFile.getAbsolutePath();
            return str;
          }
          else
          {
            i = 0;
            continue;
          }
      }
      catch (Exception localException)
      {
        return null;
      }
      label98: int i = 1;
      continue;
      label103: int j = 1;
    }
  }

  private static String getRealPathFromURI(Uri paramUri, Context paramContext)
  {
    String[] arrayOfString = { "_data" };
    Cursor localCursor = paramContext.getContentResolver().query(paramUri, arrayOfString, null, null, null);
    int i = localCursor.getColumnIndexOrThrow("_data");
    localCursor.moveToFirst();
    String str = localCursor.getString(i);
    localCursor.close();
    return str;
  }

  public static String getRelativeLocationString(float paramFloat1, float paramFloat2, boolean paramBoolean1, boolean paramBoolean2)
  {
    double d;
    if (paramBoolean2)
    {
      d = 3.28084D * paramFloat1;
      if (d < 160934.0D);
    }
    try
    {
      StringBuilder localStringBuilder7 = new StringBuilder();
      Object[] arrayOfObject6 = new Object[1];
      arrayOfObject6[0] = Double.valueOf(d / 5280.0D);
      String str1 = String.format("%.0f", arrayOfObject6) + " mi";
      label104: StringBuilder localStringBuilder2;
      if (paramBoolean1)
      {
        if (paramFloat1 < 10.0F)
          str1 = str1 + " here";
      }
      else
      {
        localStringBuilder2 = new StringBuilder().append("imperial ").append(paramBoolean2).append(" distance ").append(paramFloat1);
        if (!paramBoolean2)
          break label842;
      }
      label842: for (String str2 = " converted " + str1; ; str2 = "")
      {
        MetaioCloudPlugin.log("getRelativeLocationString", str2);
        return str1;
        if (d >= 1609.3399999999999D)
        {
          StringBuilder localStringBuilder5 = new StringBuilder();
          Object[] arrayOfObject4 = new Object[1];
          arrayOfObject4[0] = Double.valueOf(d / 5280.0D);
          str1 = String.format("%.1f", arrayOfObject4) + " mi";
          break;
        }
        StringBuilder localStringBuilder6 = new StringBuilder();
        Object[] arrayOfObject5 = new Object[1];
        arrayOfObject5[0] = Double.valueOf(d);
        str1 = String.format("%.0f", arrayOfObject5) + " ft";
        break;
        if (paramFloat1 >= 100000.0F)
        {
          StringBuilder localStringBuilder1 = new StringBuilder();
          Object[] arrayOfObject1 = new Object[1];
          arrayOfObject1[0] = Float.valueOf(paramFloat1 / 1000.0F);
          str1 = String.format("%.0f", arrayOfObject1) + "Km";
          break;
        }
        if (paramFloat1 >= 1000.0F)
        {
          StringBuilder localStringBuilder3 = new StringBuilder();
          Object[] arrayOfObject2 = new Object[1];
          arrayOfObject2[0] = Float.valueOf(paramFloat1 / 1000.0F);
          str1 = String.format("%.1f", arrayOfObject2) + "Km";
          break;
        }
        StringBuilder localStringBuilder4 = new StringBuilder();
        Object[] arrayOfObject3 = new Object[1];
        arrayOfObject3[0] = Float.valueOf(paramFloat1);
        str1 = String.format("%.0f", arrayOfObject3) + "m";
        break;
        if ((paramFloat2 >= 0.0F) && (paramFloat2 <= 22.5D))
        {
          str1 = str1 + " N";
          break label104;
        }
        if ((paramFloat2 > 22.5D) && (paramFloat2 <= 67.5D))
        {
          str1 = str1 + " NE";
          break label104;
        }
        if ((paramFloat2 > 67.5D) && (paramFloat2 <= 112.5D))
        {
          str1 = str1 + " E";
          break label104;
        }
        if ((paramFloat2 > 112.5D) && (paramFloat2 <= 157.5D))
        {
          str1 = str1 + " SE";
          break label104;
        }
        if ((paramFloat2 > 157.5D) && (paramFloat2 <= 202.5D))
        {
          str1 = str1 + " S";
          break label104;
        }
        if ((paramFloat2 > 202.5D) && (paramFloat2 <= 247.5D))
        {
          str1 = str1 + " SW";
          break label104;
        }
        if ((paramFloat2 > 247.5D) && (paramFloat2 <= 292.5D))
        {
          str1 = str1 + " W";
          break label104;
        }
        if ((paramFloat2 > 292.5D) && (paramFloat2 <= 337.5D))
        {
          str1 = str1 + " NW";
          break label104;
        }
        if ((paramFloat2 <= 337.5D) || (paramFloat2 > 360.0F))
          break label104;
        str1 = str1 + " N";
        break label104;
      }
    }
    catch (Exception localException)
    {
      MetaioCloudPlugin.log("getRelativeLocation: " + localException.getMessage());
    }
    return "";
  }

  public static String getUDID()
  {
    if (TextUtils.isEmpty(imei))
      imei = UUID.randomUUID().toString();
    return imei;
  }

  public static String getUserAgentString()
  {
    if (TextUtils.isEmpty(userAgent))
      userAgent = "com.metaio.junaio/5.3.2 ";
    return userAgent;
  }

  public static String getVersionCode(Context paramContext)
  {
    try
    {
      String str = Integer.toString(paramContext.getPackageManager().getPackageInfo(paramContext.getPackageName(), 0).versionCode);
      return str;
    }
    catch (PackageManager.NameNotFoundException localNameNotFoundException)
    {
      MetaioCloudPlugin.log(localNameNotFoundException.getMessage());
    }
    return "";
  }

  public static String makeUserAgentString(Context paramContext)
  {
    try
    {
      PackageInfo localPackageInfo = paramContext.getPackageManager().getPackageInfo(paramContext.getPackageName(), 0);
      userAgent = paramContext.getPackageName() + "/" + localPackageInfo.versionName + " ";
      userAgent = userAgent + Build.MANUFACTURER + " " + Build.MODEL;
      userAgent = userAgent + "/Android/" + Build.VERSION.RELEASE;
      MetaioCloudPlugin.log("User-Agent: " + userAgent);
      return userAgent;
    }
    catch (Exception localException)
    {
      while (true)
        userAgent = "com.metaio.junaio/5.3.2 ";
    }
  }

  public static JunaioChannel parseUrl(Uri paramUri)
  {
    int i = 4;
    MetaioDebug.log("Application launched from: " + paramUri);
    List localList2;
    Object localObject2;
    if (paramUri.getScheme().equalsIgnoreCase("junaio"))
    {
      localList2 = paramUri.getPathSegments();
      if (localList2.size() == 1)
        if (((String)localList2.get(0)).compareToIgnoreCase("switchChannel") == 0)
        {
          String[] arrayOfString3 = paramUri.getQuery().split("&");
          JunaioChannel localJunaioChannel3 = new JunaioChannel();
          int n = 0;
          if (n < arrayOfString3.length)
          {
            String[] arrayOfString4 = arrayOfString3[n].split("=");
            if (arrayOfString4[0].compareToIgnoreCase("id") == 0)
              localJunaioChannel3.setChannelID(Integer.parseInt(arrayOfString4[1]));
            while (true)
            {
              n++;
              break;
              localJunaioChannel3.addFilter(arrayOfString4[0], arrayOfString4[1]);
            }
          }
          localObject2 = localJunaioChannel3;
        }
    }
    while (true)
    {
      Object localObject1 = localObject2;
      label590: label592: boolean bool1;
      do
      {
        while (true)
        {
          return localObject1;
          if (!((String)localList2.get(0)).contains("id="))
            break label664;
          String[] arrayOfString1 = ((String)localList2.get(0)).split("&");
          JunaioChannel localJunaioChannel2 = new JunaioChannel();
          int m = 0;
          if (m < arrayOfString1.length)
          {
            String[] arrayOfString2 = arrayOfString1[m].split("=");
            if (arrayOfString2[0].compareToIgnoreCase("id") == 0)
              localJunaioChannel2.setChannelID(Integer.parseInt(arrayOfString2[1]));
            while (true)
            {
              m++;
              break;
              localJunaioChannel2.addFilter(arrayOfString2[0], arrayOfString2[1]);
            }
          }
          localObject2 = localJunaioChannel2;
          break;
          String str = paramUri.getQueryParameter("id");
          if (str == null)
            break label664;
          localObject2 = new JunaioChannel(Integer.parseInt(str));
          break;
          if (!paramUri.getScheme().equals("http"))
            break label592;
          List localList1 = paramUri.getPathSegments();
          if ((paramUri.getHost().equals("dev.junaio.com")) && (localList1.size() > 3))
            localObject1 = new JunaioChannel(Integer.parseInt((String)localList1.get(3)));
          while (true)
          {
            if ((localList1.size() <= i) || (localObject1 == null))
              break label590;
            int k = localList1.size();
            while (i < k)
            {
              if (localList1.size() > i + 1)
                ((JunaioChannel)localObject1).addFilter((String)localList1.get(i), (String)localList1.get(i + 1));
              i += 2;
            }
            break;
            if ((paramUri.getHost().equals("www.junaio.com")) && (localList1.size() > 3))
            {
              localObject1 = new JunaioChannel(Integer.parseInt((String)localList1.get(3)));
            }
            else
            {
              boolean bool2 = paramUri.getHost().equals("juna.io");
              localObject1 = null;
              if (bool2)
              {
                int j = localList1.size();
                localObject1 = null;
                if (j > 0)
                  localObject1 = new JunaioChannel(Integer.parseInt((String)localList1.get(0)));
              }
            }
          }
        }
        if (paramUri.getScheme().equals("ar"))
          break label625;
        bool1 = paramUri.getScheme().equals("sar");
        localObject1 = null;
      }
      while (!bool1);
      try
      {
        label625: Object[] arrayOfObject = new Object[1];
        arrayOfObject[0] = URLEncoder.encode(paramUri.toString(), "UTF-8");
        JunaioChannel localJunaioChannel1 = parseUrl(Uri.parse(String.format("junaio://channel/switchChannel/?id=232001&filter_arlink=%s", arrayOfObject)));
        return localJunaioChannel1;
      }
      catch (UnsupportedEncodingException localUnsupportedEncodingException)
      {
        return null;
      }
      label664: localObject2 = null;
    }
  }

  public static String readUDID(Context paramContext)
  {
    try
    {
      SharedPreferences localSharedPreferences = paramContext.getSharedPreferences("junaio", 0);
      if (localSharedPreferences.contains("imei"))
        imei = localSharedPreferences.getString("imei", Settings.Secure.getString(paramContext.getContentResolver(), "android_id"));
      label45: if (TextUtils.isEmpty(imei))
      {
        MetaioCloudPlugin.log(5, "UDID not available");
        imei = String.valueOf(UUID.randomUUID().getMostSignificantBits());
      }
      try
      {
        paramContext.getSharedPreferences("junaio", 0).edit().putString("imei", imei).commit();
        label102: return imei;
      }
      catch (Exception localException2)
      {
        break label102;
      }
    }
    catch (Exception localException1)
    {
      break label45;
    }
  }

  public static boolean removeDirectory(File paramFile, long paramLong)
  {
    while (true)
    {
      File[] arrayOfFile;
      int i;
      try
      {
        if (!paramFile.exists())
          break label203;
        arrayOfFile = paramFile.listFiles();
        i = 0;
        if (i >= arrayOfFile.length)
          break label203;
        if (arrayOfFile[i].isDirectory())
        {
          removeDirectory(arrayOfFile[i], paramLong);
        }
        else if (paramLong > 0L)
        {
          long l2 = arrayOfFile[i].lastModified();
          if (Math.abs(System.currentTimeMillis() - l2) <= 1000L * (3600L * paramLong))
            break label272;
          boolean bool4 = arrayOfFile[i].delete();
          MetaioCloudPlugin.log("Deleted file: " + bool4 + " : " + arrayOfFile[i].getPath());
        }
      }
      finally
      {
      }
      boolean bool5 = arrayOfFile[i].delete();
      MetaioCloudPlugin.log("Deleted file: " + bool5 + " : " + arrayOfFile[i].getPath());
      break label272;
      label203: boolean bool1;
      if (paramLong > 0L)
      {
        long l1 = paramFile.lastModified();
        if (Math.abs(System.currentTimeMillis() - l1) > 1000L * (3600L * paramLong))
        {
          boolean bool2 = paramFile.delete();
          bool1 = bool2;
        }
      }
      while (true)
      {
        return bool1;
        bool1 = true;
        continue;
        boolean bool3 = paramFile.delete();
        bool1 = bool3;
      }
      label272: i++;
    }
  }

  public static String saveScreenshot(Bitmap paramBitmap, Context paramContext, String paramString)
    throws IOException, Exception
  {
    if (paramString == null);
    while (true)
    {
      try
      {
        str1 = generateNameBasedOnTimestamp("metaio");
        String str2 = getPicturesPath();
        writeToFile(paramBitmap, Bitmap.CompressFormat.JPEG, 100, str2, str1, false);
        String str3 = MediaStore.Images.Media.insertImage(paramContext.getContentResolver(), paramBitmap, str1, "screenshot");
        if (str3 != null)
        {
          String str4 = getRealPathFromURI(Uri.parse(str3), paramContext);
          Context localContext = paramContext.getApplicationContext();
          String[] arrayOfString = new String[1];
          arrayOfString[0] = new File(str2, str1).getAbsolutePath();
          MediaScannerConnection.scanFile(localContext, arrayOfString, new String[] { "image/jpg" }, new MediaScannerConnection.OnScanCompletedListener()
          {
            public void onScanCompleted(String paramAnonymousString, Uri paramAnonymousUri)
            {
              MetaioCloudPlugin.log(String.format("Saved path %s uri %s", new Object[] { paramAnonymousString, paramAnonymousUri }));
            }
          });
          return str4;
        }
      }
      catch (Exception localException)
      {
        MetaioCloudPlugin.log(6, "error saving image", localException);
      }
      return null;
      String str1 = paramString;
    }
  }

  public static boolean shouldUseImperialUnits(Locale paramLocale)
  {
    return Arrays.asList(new String[] { "US", "LR", "MM" }).contains(paramLocale.getCountry());
  }

  public static void showMessage(Activity paramActivity, final String paramString1, final String paramString2)
  {
    paramActivity.runOnUiThread(new Runnable()
    {
      public void run()
      {
        try
        {
          AlertDialog.Builder localBuilder = new AlertDialog.Builder(this.val$activity);
          localBuilder.setCancelable(true);
          localBuilder.setPositiveButton(MetaioCloudPlugin.getResourceString(this.val$activity.getApplicationContext(), "BTN_OK"), new DialogInterface.OnClickListener()
          {
            public void onClick(DialogInterface paramAnonymous2DialogInterface, int paramAnonymous2Int)
            {
            }
          });
          localBuilder.setTitle(paramString1);
          localBuilder.setMessage(paramString2);
          localBuilder.show();
          return;
        }
        catch (Exception localException)
        {
          MetaioCloudPlugin.log("Alert dialog failed: " + localException.getMessage());
        }
      }
    });
  }

  public static void showToast(Activity paramActivity, final String paramString)
  {
    if ((paramActivity != null) && (paramString != null))
      paramActivity.runOnUiThread(new Runnable()
      {
        public void run()
        {
          Toast localToast = Toast.makeText(this.val$activity.getApplicationContext(), paramString, 0);
          localToast.setGravity(16, 0, 0);
          localToast.show();
        }
      });
  }

  // ERROR //
  public static void unbindDrawables(android.view.View paramView)
  {
    // Byte code:
    //   0: aload_0
    //   1: invokevirtual 646	android/view/View:getBackground	()Landroid/graphics/drawable/Drawable;
    //   4: ifnull +11 -> 15
    //   7: aload_0
    //   8: invokevirtual 646	android/view/View:getBackground	()Landroid/graphics/drawable/Drawable;
    //   11: aconst_null
    //   12: invokevirtual 652	android/graphics/drawable/Drawable:setCallback	(Landroid/graphics/drawable/Drawable$Callback;)V
    //   15: aload_0
    //   16: instanceof 654
    //   19: ifeq +40 -> 59
    //   22: iconst_0
    //   23: istore_2
    //   24: iload_2
    //   25: aload_0
    //   26: checkcast 654	android/view/ViewGroup
    //   29: invokevirtual 657	android/view/ViewGroup:getChildCount	()I
    //   32: if_icmpge +20 -> 52
    //   35: aload_0
    //   36: checkcast 654	android/view/ViewGroup
    //   39: iload_2
    //   40: invokevirtual 661	android/view/ViewGroup:getChildAt	(I)Landroid/view/View;
    //   43: invokestatic 663	com/metaio/cloud/plugin/util/MetaioCloudUtils:unbindDrawables	(Landroid/view/View;)V
    //   46: iinc 2 1
    //   49: goto -25 -> 24
    //   52: aload_0
    //   53: checkcast 654	android/view/ViewGroup
    //   56: invokevirtual 666	android/view/ViewGroup:removeAllViews	()V
    //   59: return
    //   60: astore_1
    //   61: return
    //   62: astore_3
    //   63: return
    //
    // Exception table:
    //   from	to	target	type
    //   0	15	60	java/lang/Exception
    //   15	22	60	java/lang/Exception
    //   24	46	60	java/lang/Exception
    //   52	59	60	java/lang/Exception
    //   52	59	62	java/lang/UnsupportedOperationException
  }

  public static String[] wrapText(String paramString, int paramInt)
  {
    int i = 0;
    if (paramString == null)
      return new String[0];
    if (paramInt <= 0)
      return new String[] { paramString };
    if (paramString.length() <= paramInt)
      return new String[] { paramString };
    char[] arrayOfChar = paramString.toCharArray();
    Vector localVector = new Vector();
    StringBuffer localStringBuffer1 = new StringBuffer();
    StringBuffer localStringBuffer2 = new StringBuffer();
    for (int j = 0; j < arrayOfChar.length; j++)
    {
      localStringBuffer2.append(arrayOfChar[j]);
      if (arrayOfChar[j] == ' ')
      {
        if (localStringBuffer1.length() + localStringBuffer2.length() > paramInt)
        {
          localVector.add(localStringBuffer1.toString());
          localStringBuffer1.delete(0, localStringBuffer1.length());
        }
        localStringBuffer1.append(localStringBuffer2);
        localStringBuffer2.delete(0, localStringBuffer2.length());
      }
    }
    if (localStringBuffer2.length() > 0)
    {
      if (localStringBuffer1.length() + localStringBuffer2.length() > paramInt)
      {
        localVector.add(localStringBuffer1.toString());
        localStringBuffer1.delete(0, localStringBuffer1.length());
      }
      localStringBuffer1.append(localStringBuffer2);
    }
    if (localStringBuffer1.length() > 0)
      localVector.add(localStringBuffer1.toString());
    String[] arrayOfString = new String[localVector.size()];
    Enumeration localEnumeration = localVector.elements();
    while (localEnumeration.hasMoreElements())
    {
      arrayOfString[i] = ((String)localEnumeration.nextElement());
      i++;
    }
    return arrayOfString;
  }

  public static boolean writeToFile(Bitmap paramBitmap, Bitmap.CompressFormat paramCompressFormat, int paramInt, String paramString1, String paramString2, boolean paramBoolean)
    throws IOException
  {
    try
    {
      new File(paramString1).mkdirs();
      File localFile = new File(paramString1, paramString2);
      localFile.createNewFile();
      if (paramBoolean)
        localFile.deleteOnExit();
      FileOutputStream localFileOutputStream = new FileOutputStream(localFile);
      boolean bool = paramBitmap.compress(paramCompressFormat, paramInt, localFileOutputStream);
      localFileOutputStream.close();
      return bool;
    }
    finally
    {
    }
  }

  public static boolean writeToFile(InputStream paramInputStream, String paramString1, String paramString2)
    throws IOException
  {
    long l;
    FileOutputStream localFileOutputStream;
    try
    {
      MetaioCloudPlugin.log("Writing to file: " + paramString1 + "/" + paramString2);
      l = System.currentTimeMillis();
      new File(paramString1).mkdirs();
      File localFile = new File(paramString1, paramString2);
      localFile.createNewFile();
      localFileOutputStream = new FileOutputStream(localFile);
      byte[] arrayOfByte = new byte[16348];
      while (true)
      {
        int i = paramInputStream.read(arrayOfByte);
        if (i == -1)
          break;
        localFileOutputStream.write(arrayOfByte, 0, i);
      }
    }
    finally
    {
    }
    paramInputStream.close();
    localFileOutputStream.close();
    double d = (System.currentTimeMillis() - l) / 1000L;
    MetaioCloudPlugin.log("Done writing to file: " + paramString1 + "/" + paramString2 + " time: " + d + "s");
    return true;
  }

  public static boolean writeToFile(byte[] paramArrayOfByte, String paramString1, String paramString2, boolean paramBoolean)
    throws IOException
  {
    try
    {
      new File(paramString1).mkdirs();
      File localFile = new File(paramString1, paramString2);
      if ((!localFile.exists()) || (!paramBoolean))
        localFile.createNewFile();
      FileOutputStream localFileOutputStream = new FileOutputStream(localFile);
      localFileOutputStream.write(paramArrayOfByte);
      localFileOutputStream.close();
      return true;
    }
    finally
    {
    }
  }
}

/* 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.MetaioCloudUtils
 * JD-Core Version:    0.6.2
 */