// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package com.oliodevices.assist.app.detectors.firmware;

import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.AsyncTask;
import com.olio.communication.filetransfer.Utilities;
import com.olio.communication.messages.MessageBuilder;
import com.olio.communication.messages.MessagePayload;
import com.olio.communication.messages.files.FileMetadataBuilder;
import com.olio.communication.messages.unit.WatchProfile;
import com.olio.data.object.transfer.FileTransfer;
import com.olio.data.object.transfer.FileTransferBuilder;
import com.olio.data.object.transfer.FileTransferObserver;
import com.olio.data.object.unit.FirmwareProfile;
import com.olio.data.object.unit.FirmwareProfileBuilder;
import com.olio.state.Firmware;
import com.olio.state.Product;
import com.olio.state.Unit;
import com.olio.util.ALog;
import com.olio.util.FileHash;
import com.oliodevices.assist.app.api.OlioApi;
import com.oliodevices.assist.app.api.UserManager;
import com.oliodevices.assist.app.detectors.BroadcastDelegate;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import retrofit.Callback;
import retrofit.RetrofitError;
import retrofit.client.Response;

public class FirmwareUpdateHelper
{

    public static final String ACTION_FIRMWARE_UPDATE_AVAILABLE = "com.oliodevices.assist.intent.action.FIRMWARE_AVAILABLE";
    public static final String EXTRA_AVAILABLE_FIRMWARE_NAME = "available_firmware_name";
    public static final String EXTRA_AVAILABLE_FIRMWARE_VERSION = "available_firmware_version";
    private static FirmwareUpdateHelper sInstance;
    private String firmwareUpdateDirectory;
    private String firmwareUpdateFileFullPath;
    private String firmwareUpdateFileName;
    private Context mContext;
    private BroadcastDelegate mDelegate;
    private FileTransfer mFirmwareTransfer;
    private boolean mIsDownloading;

    public FirmwareUpdateHelper()
    {
        firmwareUpdateFileName = "olio-firmware.zip";
        mIsDownloading = false;
        mFirmwareTransfer = null;
    }

    private FirmwareProfile buildFirmwareProfile(Firmware firmware, File file)
    {
        return FirmwareProfileBuilder.aFirmwareProfile().setVersion(firmware.getVersion()).setName(firmware.getName()).setFileMetadata((new FileMetadataBuilder()).setSource("android").setFileIdentifier(file.getName()).setFileLength((int)file.length()).setMd5Hash(firmware.getFirmwareHash()).build()).build();
    }

    private void checkAndSendUpdate(File file, String s, MessagePayload messagepayload)
    {
        try
        {
            checkAndSendUpdate(new FileInputStream(file), s, messagepayload);
            ALog.d((new StringBuilder()).append("Sent file: ").append(file).toString(), new Object[0]);
            return;
        }
        // Misplaced declaration of an exception variable
        catch (File file)
        {
            ALog.e("Couldn't find this file", file, new Object[0]);
            return;
        }
        // Misplaced declaration of an exception variable
        catch (File file)
        {
            ALog.e("No file in this directory", file, new Object[0]);
        }
    }

    private void checkAndSendUpdate(FileInputStream fileinputstream, String s, MessagePayload messagepayload)
    {
        FileInputStream fileinputstream1;
        String s1;
        fileinputstream1 = null;
        s1 = null;
        if (fileinputstream == null)
        {
            break MISSING_BLOCK_LABEL_123;
        }
        s = mContext.openFileOutput(s, 0);
        fileinputstream1 = fileinputstream;
        s1 = s;
        Utilities.copyFile(fileinputstream, s);
        fileinputstream1 = fileinputstream;
        s1 = s;
        messagepayload = (new MessageBuilder()).setAction(com.olio.communication.messages.Message.Action.CREATE_OR_UPDATE).setPayload(messagepayload).build();
        fileinputstream1 = fileinputstream;
        s1 = s;
        mDelegate.sendMessage(messagepayload);
        if (fileinputstream == null)
        {
            break MISSING_BLOCK_LABEL_80;
        }
        fileinputstream.close();
        if (s != null)
        {
            try
            {
                s.close();
                return;
            }
            // Misplaced declaration of an exception variable
            catch (FileInputStream fileinputstream)
            {
                ALog.e("Error copying file from public to private olio directory", fileinputstream, new Object[0]);
            }
        }
        break MISSING_BLOCK_LABEL_123;
        fileinputstream;
        if (fileinputstream1 == null)
        {
            break MISSING_BLOCK_LABEL_100;
        }
        fileinputstream1.close();
        if (s1 == null)
        {
            break MISSING_BLOCK_LABEL_110;
        }
        s1.close();
        throw fileinputstream;
    }

    private void downloadAndSendFirmwareUpdate(final Firmware firmware)
    {
        final String firmwareUrl = firmware.getFirmwareUrl();
        ALog.d(firmwareUrl, new Object[0]);
        ConnectivityManager connectivitymanager = (ConnectivityManager)mContext.getSystemService("connectivity");
        if (!mIsDownloading && connectivitymanager.getNetworkInfo(1).isConnected())
        {
            Utilities.clearDirectory(firmwareUpdateDirectory);
            mIsDownloading = true;
            (new AsyncTask() {

                final FirmwareUpdateHelper this$0;
                final Firmware val$firmware;
                final String val$firmwareUrl;

                protected transient Boolean doInBackground(Void avoid[])
                {
                    try
                    {
                        downloadUrl(firmwareUrl, firmwareUpdateFileFullPath);
                    }
                    // Misplaced declaration of an exception variable
                    catch (Void avoid[])
                    {
                        ALog.d("IOE: %s", new Object[] {
                            avoid.getLocalizedMessage()
                        });
                        return Boolean.valueOf(false);
                    }
                    return Boolean.valueOf(true);
                }

                protected volatile Object doInBackground(Object aobj[])
                {
                    return doInBackground((Void[])aobj);
                }

                protected void onPostExecute(Boolean boolean1)
                {
                    mIsDownloading = false;
                    if (boolean1.booleanValue())
                    {
                        ALog.d("Finished downloading the Firmware, sending to the watch", new Object[0]);
                        sendFirmwareUpdateFile(firmware);
                        mContext.sendStickyBroadcast((new Intent("com.oliodevices.assist.intent.action.FIRMWARE_AVAILABLE")).putExtra("available_firmware_version", firmware.getVersion()).putExtra("available_firmware_name", firmware.getName()));
                        return;
                    } else
                    {
                        ALog.d("Failure downloading the Firmware update file", new Object[0]);
                        return;
                    }
                }

                protected volatile void onPostExecute(Object obj)
                {
                    onPostExecute((Boolean)obj);
                }

            
            {
                this$0 = FirmwareUpdateHelper.this;
                firmwareUrl = s;
                firmware = firmware1;
                super();
            }
            }).execute(new Void[0]);
        }
    }

    private boolean downloadUrl(String s, String s1)
        throws IOException
    {
        s = (HttpURLConnection)(new URL(s)).openConnection();
        s.setRequestMethod("GET");
        s.connect();
        s = s.getInputStream();
        File file = new File(firmwareUpdateDirectory);
        if (!file.exists())
        {
            file.mkdirs();
        }
        s1 = new FileOutputStream(s1);
        byte abyte0[] = new byte[1024];
        do
        {
            int i = s.read(abyte0);
            if (i != -1)
            {
                s1.write(abyte0, 0, i);
            } else
            {
                s1.close();
                return true;
            }
        } while (true);
    }

    public static FirmwareUpdateHelper getInstance()
    {
        if (sInstance == null)
        {
            sInstance = new FirmwareUpdateHelper();
        }
        return sInstance;
    }

    private void sendFirmwareUpdateFile(Firmware firmware)
    {
        File file = new File(firmwareUpdateFileFullPath);
        String s = FileHash.md5(file);
        if (!s.equals(firmware.getFirmwareHash()))
        {
            ALog.e("Hash for downloaded file does not match expected hash", new Object[0]);
            return;
        } else
        {
            removeAllFirmwareTransfers();
            mFirmwareTransfer = FileTransferBuilder.aFileTransfer().setBytesTransferred(0).setFileIdentifier(file.getName()).setFileSize((int)file.length()).setExpectedHash(s).setStatus(0).setObserver(null).build();
            ALog.d("created new fileTransfer object: %s", new Object[] {
                mFirmwareTransfer.toString()
            });
            FileTransfer.firstOrCreateTransfer(mFirmwareTransfer, mContext.getContentResolver());
            checkAndSendUpdate(file, file.getName(), buildFirmwareProfile(firmware, file));
            return;
        }
    }

    private void sendFirmwareUpdateProfile(File file, Firmware firmware)
    {
        file = (new MessageBuilder()).setAction(com.olio.communication.messages.Message.Action.CREATE_OR_UPDATE).setPayload(buildFirmwareProfile(firmware, file)).build();
        mDelegate.sendMessage(file);
    }

    public void checkFileHash(Firmware firmware)
    {
        File file = new File(firmwareUpdateFileFullPath);
        String s = firmware.getFirmwareHash();
        ALog.d(s, new Object[0]);
        if (s.equals(FileHash.md5(file)))
        {
            if (mFirmwareTransfer == null)
            {
                ALog.w("File hash matched but transfer is missing.  Recreating...", new Object[0]);
                sendFirmwareUpdateFile(firmware);
            } else
            {
                ALog.d("File hash matched. Sending firmware profile again.", new Object[0]);
                sendFirmwareUpdateProfile(file, firmware);
            }
            mContext.sendStickyBroadcast((new Intent("com.oliodevices.assist.intent.action.FIRMWARE_AVAILABLE")).putExtra("available_firmware_version", firmware.getVersion()).putExtra("available_firmware_name", firmware.getName()));
            return;
        } else
        {
            ALog.d("File hash didn't match. Downloading the latest firmware file from the backend", new Object[0]);
            downloadAndSendFirmwareUpdate(firmware);
            return;
        }
    }

    public FileTransfer getFirmwareTransfer()
    {
        if (mFirmwareTransfer == null && mContext != null)
        {
            mFirmwareTransfer = FileTransfer.transferForFileIdentifier(firmwareUpdateFileName, mContext.getContentResolver());
        }
        return mFirmwareTransfer;
    }

    public FileTransfer getFirmwareTransferInMem()
    {
        return mFirmwareTransfer;
    }

    public void getFirmwareUpdate()
    {
        if (mContext == null)
        {
            ALog.e("You must initialize with a context first.", new Object[0]);
            return;
        } else
        {
            OlioApi.getInstance().getUnitDetails(getUnitMacAddress(), new Callback() {

                final FirmwareUpdateHelper this$0;

                public void failure(RetrofitError retrofiterror)
                {
                    ALog.d("Failed to get the unit details", new Object[0]);
                }

                public void success(Unit unit, Response response)
                {
                    ALog.d(unit.toString(), new Object[0]);
                    unit.save(mContext.getContentResolver());
                    response = WatchProfile.get(mContext.getContentResolver(), getUnitMacAddress());
                    if (response != null)
                    {
                        ALog.d("Watch: %s %s  Server: %s %s", new Object[] {
                            response.getFirmwareName(), response.getFirmwareVersion(), unit.getFirmware().getName(), unit.getFirmware().getVersion()
                        });
                        if ("unknown".equals(response.getFirmwareVersion()))
                        {
                            ALog.i("WatchProfile is still unknown.  Proceed to validate and send firmware.", new Object[0]);
                        } else
                        if (unit.getFirmware().getVersion().equals(response.getFirmwareVersion()) && unit.getFirmware().getName().equals(response.getFirmwareName()))
                        {
                            ALog.v("Watch already has this firmware.", new Object[0]);
                            removeAllFirmwareTransfers();
                            mContext.sendStickyBroadcast((new Intent("com.oliodevices.assist.intent.action.FIRMWARE_AVAILABLE")).putExtra("available_firmware_version", unit.getFirmware().getVersion()).putExtra("available_firmware_name", unit.getFirmware().getName()));
                            return;
                        }
                    }
                    if (unit.getFirmware() != null)
                    {
                        checkFileHash(unit.getFirmware());
                    } else
                    if (unit.getProduct() != null)
                    {
                        checkFileHash(unit.getProduct().getDefaultFirmware());
                        return;
                    }
                }

                public volatile void success(Object obj, Response response)
                {
                    success((Unit)obj, response);
                }

            
            {
                this$0 = FirmwareUpdateHelper.this;
                super();
            }
            });
            return;
        }
    }

    public String getUnitMacAddress()
    {
        return UserManager.getInstance().getUnitId();
    }

    public FirmwareUpdateHelper initialize(Context context)
    {
        sInstance.mContext = context;
        sInstance.firmwareUpdateDirectory = (new StringBuilder()).append(context.getCacheDir().getAbsolutePath()).append(File.separator).append("firmware_updates").append(File.separator).toString();
        sInstance.firmwareUpdateFileFullPath = (new StringBuilder()).append(sInstance.firmwareUpdateDirectory).append(firmwareUpdateFileName).toString();
        sInstance.mDelegate = new BroadcastDelegate(context);
        return sInstance;
    }

    public void removeAllFirmwareTransfers()
    {
        mFirmwareTransfer = null;
        if (mContext != null)
        {
            FileTransfer.removeAllTransfersForFileIdentifier(firmwareUpdateFileName, mContext.getContentResolver());
        }
    }

    public void removeFirmwareTransfer()
    {
        if (mFirmwareTransfer != null && mContext != null)
        {
            mFirmwareTransfer.removeTransfer(mContext.getContentResolver());
        }
        mFirmwareTransfer = null;
    }

    public int setFirmwareTransferObserver(FileTransferObserver filetransferobserver)
    {
        getFirmwareTransfer();
        if (mFirmwareTransfer != null && mContext != null)
        {
            int i;
            synchronized (mFirmwareTransfer)
            {
                mFirmwareTransfer.setObserver(filetransferobserver);
                i = mFirmwareTransfer.update(mContext.getContentResolver());
            }
            return i;
        } else
        {
            return 0;
        }
        filetransferobserver;
        filetransfer;
        JVM INSTR monitorexit ;
        throw filetransferobserver;
    }

    public int updateFirmwareTransfer(int i, int j)
    {
        return updateFirmwareTransfer(i, j, 0);
    }

    public int updateFirmwareTransfer(int i, int j, int k)
    {
        getFirmwareTransfer();
        if (mFirmwareTransfer != null && mContext != null)
        {
            synchronized (mFirmwareTransfer)
            {
                mFirmwareTransfer.setBytesTransferred(j);
                mFirmwareTransfer.setStatus(i);
                mFirmwareTransfer.setPausedReason(k);
                i = mFirmwareTransfer.update(mContext.getContentResolver());
            }
            return i;
        } else
        {
            return 0;
        }
        exception;
        filetransfer;
        JVM INSTR monitorexit ;
        throw exception;
    }





/*
    static boolean access$302(FirmwareUpdateHelper firmwareupdatehelper, boolean flag)
    {
        firmwareupdatehelper.mIsDownloading = flag;
        return flag;
    }

*/

}