package net.hockeyapp.android.metrics;

import android.annotation.TargetApi;
import android.app.Activity;
import android.app.Application;
import android.app.Application.ActivityLifecycleCallbacks;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.os.AsyncTask;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import java.lang.ref.WeakReference;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import net.hockeyapp.android.Constants;
import net.hockeyapp.android.PrivateEventManager;
import net.hockeyapp.android.PrivateEventManager.Event;
import net.hockeyapp.android.PrivateEventManager.HockeyEventListener;
import net.hockeyapp.android.metrics.model.Data;
import net.hockeyapp.android.metrics.model.Domain;
import net.hockeyapp.android.metrics.model.SessionState;
import net.hockeyapp.android.metrics.model.TelemetryData;
import net.hockeyapp.android.utils.AsyncTaskUtils;
import net.hockeyapp.android.utils.HockeyLog;
import net.hockeyapp.android.utils.Util;
import tr;
import ts;
import tt;

public class MetricsManager
{
  protected static final AtomicInteger ACTIVITY_COUNT = new AtomicInteger(0);
  protected static final AtomicLong LAST_BACKGROUND = new AtomicLong(f());
  private static boolean a = true;
  private static final Integer b = Integer.valueOf(20000);
  private static final Object c = new Object();
  private static volatile MetricsManager d;
  private static WeakReference<Application> e;
  private static Sender f;
  private static tr g;
  private static tt h;
  private volatile boolean i;
  private a j;
  
  protected MetricsManager(Context paramContext, tt paramtt, Sender paramSender, ts paramts, tr paramtr)
  {
    h = paramtt;
    paramtt = paramSender;
    if (paramSender == null) {
      paramtt = new Sender();
    }
    f = paramtt;
    if (paramts == null)
    {
      paramts = new ts(paramContext, paramtt);
      f.setPersistence(paramts);
      if (paramtr != null) {
        break label96;
      }
    }
    label96:
    for (g = new tr(h, paramts);; g = paramtr)
    {
      if (paramts.a()) {
        paramts.c().triggerSending();
      }
      return;
      paramts.a(paramtt);
      break;
    }
  }
  
  private static void a(boolean paramBoolean)
  {
    a = paramBoolean;
    if (paramBoolean)
    {
      d.c();
      return;
    }
    d.d();
  }
  
  @TargetApi(14)
  private void c()
  {
    if (this.j == null) {
      this.j = new a((byte)0);
    }
    e().registerActivityLifecycleCallbacks(this.j);
  }
  
  protected static Data<Domain> createData(TelemetryData paramTelemetryData)
  {
    Data localData = new Data();
    localData.setBaseData(paramTelemetryData);
    localData.setBaseType(paramTelemetryData.getBaseType());
    localData.QualifiedName = paramTelemetryData.getEnvelopeName();
    return localData;
  }
  
  @TargetApi(14)
  private void d()
  {
    if (this.j == null) {
      return;
    }
    e().unregisterActivityLifecycleCallbacks(this.j);
    this.j = null;
  }
  
  public static void disableUserMetrics()
  {
    a(false);
  }
  
  private static Application e()
  {
    Application localApplication = null;
    if (e != null) {
      localApplication = (Application)e.get();
    }
    return localApplication;
  }
  
  public static void enableUserMetrics()
  {
    a(true);
  }
  
  private static long f()
  {
    return new Date().getTime();
  }
  
  protected static tr getChannel()
  {
    return g;
  }
  
  protected static MetricsManager getInstance()
  {
    return d;
  }
  
  protected static Sender getSender()
  {
    return f;
  }
  
  public static boolean isUserMetricsEnabled()
  {
    return a;
  }
  
  public static void register(Context paramContext, Application paramApplication)
  {
    String str = Util.getAppIdentifier(paramContext);
    if ((str == null) || (str.length() == 0)) {
      throw new IllegalArgumentException("HockeyApp app identifier was not configured correctly in manifest or build configuration.");
    }
    register(paramContext, paramApplication, str);
  }
  
  public static void register(Context paramContext, Application paramApplication, String paramString)
  {
    register(paramContext, paramApplication, paramString, null, null, null);
  }
  
  protected static void register(Context paramContext, Application paramApplication, String paramString, Sender paramSender, ts paramts, tr paramtr)
  {
    if (d == null) {}
    for (;;)
    {
      MetricsManager localMetricsManager;
      synchronized (c)
      {
        localMetricsManager = d;
        if (localMetricsManager == null)
        {
          Constants.loadFromContext(paramContext);
          paramContext = new MetricsManager(paramContext, new tt(paramContext, paramString), paramSender, paramts, paramtr);
          e = new WeakReference(paramApplication);
          if (!Util.sessionTrackingSupported())
          {
            bool = true;
            paramContext.i = bool;
            d = paramContext;
            if (!paramContext.i) {
              setSessionTrackingDisabled(Boolean.valueOf(false));
            }
            PrivateEventManager.addEventListener(new PrivateEventManager.HockeyEventListener()
            {
              public final void onHockeyEvent(PrivateEventManager.Event paramAnonymousEvent)
              {
                if (paramAnonymousEvent.getType() == 1) {
                  MetricsManager.a().a();
                }
              }
            });
            return;
          }
          boolean bool = false;
        }
      }
      paramContext = localMetricsManager;
    }
  }
  
  public static boolean sessionTrackingEnabled()
  {
    return (isUserMetricsEnabled()) && (!d.i);
  }
  
  public static void setCustomServerURL(String paramString)
  {
    if (f != null)
    {
      f.setCustomServerURL(paramString);
      return;
    }
    HockeyLog.warn("HA-MetricsManager", "HockeyApp couldn't set the custom server url. Please register(...) the MetricsManager before setting the server URL.");
  }
  
  protected static void setSender(Sender paramSender)
  {
    f = paramSender;
  }
  
  public static void setSessionTrackingDisabled(Boolean paramBoolean)
  {
    if ((d == null) || (!isUserMetricsEnabled()))
    {
      HockeyLog.warn("HA-MetricsManager", "MetricsManager hasn't been registered or User Metrics has been disabled. No User Metrics will be collected!");
      return;
    }
    for (;;)
    {
      synchronized (c)
      {
        if (Util.sessionTrackingSupported())
        {
          d.i = paramBoolean.booleanValue();
          if (!paramBoolean.booleanValue()) {
            d.c();
          }
          return;
        }
      }
      d.i = true;
      d.d();
    }
  }
  
  public static void trackEvent(String paramString)
  {
    if (TextUtils.isEmpty(paramString)) {
      return;
    }
    if (d == null)
    {
      Log.w("HA-MetricsManager", "MetricsManager hasn't been registered or User Metrics has been disabled. No User Metrics will be collected!");
      return;
    }
    if (!isUserMetricsEnabled())
    {
      HockeyLog.warn("User Metrics is disabled. Will not track event.");
      return;
    }
    try
    {
      AsyncTaskUtils.execute(new AsyncTask() {});
      return;
    }
    catch (RejectedExecutionException paramString)
    {
      HockeyLog.error("Could not track custom event. Executor rejected async task.", paramString);
    }
  }
  
  protected void renewSession()
  {
    Object localObject2 = UUID.randomUUID().toString();
    final Object localObject1 = h;
    HockeyLog.debug("HockeyApp-Metrics", "Configuring session context");
    ((tt)localObject1).a((String)localObject2);
    HockeyLog.debug("HockeyApp-Metrics", "Setting the isNew-flag to true, as we only count new sessions");
    ((tt)localObject1).c("true");
    localObject2 = ((tt)localObject1).g.edit();
    if (!((tt)localObject1).g.getBoolean("SESSION_IS_FIRST", false))
    {
      ((SharedPreferences.Editor)localObject2).putBoolean("SESSION_IS_FIRST", true);
      ((SharedPreferences.Editor)localObject2).apply();
      ((tt)localObject1).b("true");
      HockeyLog.debug("HockeyApp-Metrics", "It's our first session, writing true to SharedPreferences.");
    }
    for (;;)
    {
      localObject1 = SessionState.START;
      try
      {
        AsyncTaskUtils.execute(new AsyncTask() {});
        return;
      }
      catch (RejectedExecutionException localRejectedExecutionException)
      {
        HockeyLog.error("Could not track session state. Executor rejected async task.", localRejectedExecutionException);
      }
      ((tt)localObject1).b("false");
      HockeyLog.debug("HockeyApp-Metrics", "It's not their first session, writing false to SharedPreferences.");
    }
  }
  
  protected void setChannel(tr paramtr)
  {
    g = paramtr;
  }
  
  @TargetApi(14)
  final class a
    implements Application.ActivityLifecycleCallbacks
  {
    private a() {}
    
    public final void onActivityCreated(Activity paramActivity, Bundle paramBundle) {}
    
    public final void onActivityDestroyed(Activity paramActivity) {}
    
    public final void onActivityPaused(Activity paramActivity)
    {
      MetricsManager.LAST_BACKGROUND.set(MetricsManager.b());
    }
    
    public final void onActivityResumed(Activity paramActivity)
    {
      MetricsManager.a(MetricsManager.this);
    }
    
    public final void onActivitySaveInstanceState(Activity paramActivity, Bundle paramBundle) {}
    
    public final void onActivityStarted(Activity paramActivity) {}
    
    public final void onActivityStopped(Activity paramActivity) {}
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/net/hockeyapp/android/metrics/MetricsManager.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */