package android.support.v4.app;

import android.app.Notification;
import android.app.NotificationManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.os.Build.VERSION;
import android.os.Bundle;
import android.os.DeadObjectException;
import android.os.Handler;
import android.os.Handler.Callback;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.provider.Settings.Secure;
import android.support.v4.os.BuildCompat;
import android.util.Log;
import ct;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public final class NotificationManagerCompat
{
  public static final String ACTION_BIND_SIDE_CHANNEL = "android.support.BIND_NOTIFICATION_SIDE_CHANNEL";
  public static final String EXTRA_USE_SIDE_CHANNEL = "android.support.useSideChannel";
  public static final int IMPORTANCE_DEFAULT = 3;
  public static final int IMPORTANCE_HIGH = 4;
  public static final int IMPORTANCE_LOW = 2;
  public static final int IMPORTANCE_MAX = 5;
  public static final int IMPORTANCE_MIN = 1;
  public static final int IMPORTANCE_NONE = 0;
  public static final int IMPORTANCE_UNSPECIFIED = -1000;
  static final int a;
  private static final Object b = new Object();
  private static String c;
  private static Set<String> d = new HashSet();
  private static final Object g = new Object();
  private static i h;
  private static final b i;
  private final Context e;
  private final NotificationManager f;
  
  static
  {
    if (BuildCompat.isAtLeastN()) {
      i = new c();
    }
    for (;;)
    {
      a = i.a();
      return;
      if (Build.VERSION.SDK_INT >= 19) {
        i = new f();
      } else if (Build.VERSION.SDK_INT >= 14) {
        i = new e();
      } else {
        i = new d();
      }
    }
  }
  
  private NotificationManagerCompat(Context paramContext)
  {
    this.e = paramContext;
    this.f = ((NotificationManager)this.e.getSystemService("notification"));
  }
  
  private void a(j paramj)
  {
    synchronized (g)
    {
      if (h == null) {
        h = new i(this.e.getApplicationContext());
      }
      h.a.obtainMessage(0, paramj).sendToTarget();
      return;
    }
  }
  
  public static NotificationManagerCompat from(Context paramContext)
  {
    return new NotificationManagerCompat(paramContext);
  }
  
  public static Set<String> getEnabledListenerPackages(Context paramContext)
  {
    Object localObject1 = Settings.Secure.getString(paramContext.getContentResolver(), "enabled_notification_listeners");
    paramContext = b;
    if (localObject1 != null) {}
    for (;;)
    {
      int j;
      try
      {
        if (!((String)localObject1).equals(c))
        {
          String[] arrayOfString = ((String)localObject1).split(":");
          HashSet localHashSet = new HashSet(arrayOfString.length);
          int k = arrayOfString.length;
          j = 0;
          if (j < k)
          {
            ComponentName localComponentName = ComponentName.unflattenFromString(arrayOfString[j]);
            if (localComponentName != null) {
              localHashSet.add(localComponentName.getPackageName());
            }
          }
          else
          {
            d = localHashSet;
            c = (String)localObject1;
          }
        }
        else
        {
          localObject1 = d;
          return (Set<String>)localObject1;
        }
      }
      finally {}
      j += 1;
    }
  }
  
  public final boolean areNotificationsEnabled()
  {
    return i.a(this.e, this.f);
  }
  
  public final void cancel(int paramInt)
  {
    cancel(null, paramInt);
  }
  
  public final void cancel(String paramString, int paramInt)
  {
    i.a(this.f, paramString, paramInt);
    if (Build.VERSION.SDK_INT <= 19) {
      a(new a(this.e.getPackageName(), paramInt, paramString));
    }
  }
  
  public final void cancelAll()
  {
    this.f.cancelAll();
    if (Build.VERSION.SDK_INT <= 19) {
      a(new a(this.e.getPackageName()));
    }
  }
  
  public final int getImportance()
  {
    return i.a(this.f);
  }
  
  public final void notify(int paramInt, Notification paramNotification)
  {
    notify(null, paramInt, paramNotification);
  }
  
  public final void notify(String paramString, int paramInt, Notification paramNotification)
  {
    Bundle localBundle = NotificationCompat.getExtras(paramNotification);
    if ((localBundle != null) && (localBundle.getBoolean("android.support.useSideChannel"))) {}
    for (int j = 1; j != 0; j = 0)
    {
      a(new g(this.e.getPackageName(), paramInt, paramString, paramNotification));
      i.a(this.f, paramString, paramInt);
      return;
    }
    i.a(this.f, paramString, paramInt, paramNotification);
  }
  
  static final class a
    implements NotificationManagerCompat.j
  {
    final String a;
    final int b;
    final String c;
    final boolean d;
    
    public a(String paramString)
    {
      this.a = paramString;
      this.b = 0;
      this.c = null;
      this.d = true;
    }
    
    public a(String paramString1, int paramInt, String paramString2)
    {
      this.a = paramString1;
      this.b = paramInt;
      this.c = paramString2;
      this.d = false;
    }
    
    public final void a(INotificationSideChannel paramINotificationSideChannel)
      throws RemoteException
    {
      if (this.d)
      {
        paramINotificationSideChannel.cancelAll(this.a);
        return;
      }
      paramINotificationSideChannel.cancel(this.a, this.b, this.c);
    }
    
    public final String toString()
    {
      StringBuilder localStringBuilder = new StringBuilder("CancelTask[");
      localStringBuilder.append("packageName:").append(this.a);
      localStringBuilder.append(", id:").append(this.b);
      localStringBuilder.append(", tag:").append(this.c);
      localStringBuilder.append(", all:").append(this.d);
      localStringBuilder.append("]");
      return localStringBuilder.toString();
    }
  }
  
  static abstract interface b
  {
    public abstract int a();
    
    public abstract int a(NotificationManager paramNotificationManager);
    
    public abstract void a(NotificationManager paramNotificationManager, String paramString, int paramInt);
    
    public abstract void a(NotificationManager paramNotificationManager, String paramString, int paramInt, Notification paramNotification);
    
    public abstract boolean a(Context paramContext, NotificationManager paramNotificationManager);
  }
  
  static final class c
    extends NotificationManagerCompat.f
  {
    public final int a(NotificationManager paramNotificationManager)
    {
      return paramNotificationManager.getImportance();
    }
    
    public final boolean a(Context paramContext, NotificationManager paramNotificationManager)
    {
      return paramNotificationManager.areNotificationsEnabled();
    }
  }
  
  static class d
    implements NotificationManagerCompat.b
  {
    public int a()
    {
      return 1;
    }
    
    public int a(NotificationManager paramNotificationManager)
    {
      return 64536;
    }
    
    public final void a(NotificationManager paramNotificationManager, String paramString, int paramInt)
    {
      paramNotificationManager.cancel(paramString, paramInt);
    }
    
    public final void a(NotificationManager paramNotificationManager, String paramString, int paramInt, Notification paramNotification)
    {
      paramNotificationManager.notify(paramString, paramInt, paramNotification);
    }
    
    public boolean a(Context paramContext, NotificationManager paramNotificationManager)
    {
      return true;
    }
  }
  
  static class e
    extends NotificationManagerCompat.d
  {
    public final int a()
    {
      return 33;
    }
  }
  
  static class f
    extends NotificationManagerCompat.e
  {
    public boolean a(Context paramContext, NotificationManager paramNotificationManager)
    {
      return ct.a(paramContext);
    }
  }
  
  static final class g
    implements NotificationManagerCompat.j
  {
    final String a;
    final int b;
    final String c;
    final Notification d;
    
    public g(String paramString1, int paramInt, String paramString2, Notification paramNotification)
    {
      this.a = paramString1;
      this.b = paramInt;
      this.c = paramString2;
      this.d = paramNotification;
    }
    
    public final void a(INotificationSideChannel paramINotificationSideChannel)
      throws RemoteException
    {
      paramINotificationSideChannel.notify(this.a, this.b, this.c, this.d);
    }
    
    public final String toString()
    {
      StringBuilder localStringBuilder = new StringBuilder("NotifyTask[");
      localStringBuilder.append("packageName:").append(this.a);
      localStringBuilder.append(", id:").append(this.b);
      localStringBuilder.append(", tag:").append(this.c);
      localStringBuilder.append("]");
      return localStringBuilder.toString();
    }
  }
  
  static final class h
  {
    final ComponentName a;
    final IBinder b;
    
    public h(ComponentName paramComponentName, IBinder paramIBinder)
    {
      this.a = paramComponentName;
      this.b = paramIBinder;
    }
  }
  
  static final class i
    implements ServiceConnection, Handler.Callback
  {
    final Handler a;
    private final Context b;
    private final HandlerThread c;
    private final Map<ComponentName, a> d = new HashMap();
    private Set<String> e = new HashSet();
    
    public i(Context paramContext)
    {
      this.b = paramContext;
      this.c = new HandlerThread("NotificationManagerCompat");
      this.c.start();
      this.a = new Handler(this.c.getLooper(), this);
    }
    
    private void a(a parama)
    {
      if (parama.b)
      {
        this.b.unbindService(this);
        parama.b = false;
      }
      parama.c = null;
    }
    
    private void b(a parama)
    {
      if (this.a.hasMessages(3, parama.a)) {
        return;
      }
      parama.e += 1;
      if (parama.e > 6)
      {
        Log.w("NotifManCompat", "Giving up on delivering " + parama.d.size() + " tasks to " + parama.a + " after " + parama.e + " retries");
        parama.d.clear();
        return;
      }
      int i = (1 << parama.e - 1) * 1000;
      if (Log.isLoggable("NotifManCompat", 3)) {
        new StringBuilder("Scheduling retry for ").append(i).append(" ms");
      }
      parama = this.a.obtainMessage(3, parama.a);
      this.a.sendMessageDelayed(parama, i);
    }
    
    private void c(a parama)
    {
      if (Log.isLoggable("NotifManCompat", 3)) {
        new StringBuilder("Processing component ").append(parama.a).append(", ").append(parama.d.size()).append(" queued tasks");
      }
      if (parama.d.isEmpty()) {}
      for (;;)
      {
        return;
        boolean bool;
        if (parama.b)
        {
          bool = true;
          if ((!bool) || (parama.c == null)) {
            b(parama);
          }
        }
        else
        {
          localObject = new Intent("android.support.BIND_NOTIFICATION_SIDE_CHANNEL").setComponent(parama.a);
          parama.b = this.b.bindService((Intent)localObject, this, NotificationManagerCompat.a);
          if (parama.b) {
            parama.e = 0;
          }
          for (;;)
          {
            bool = parama.b;
            break;
            Log.w("NotifManCompat", "Unable to bind to listener " + parama.a);
            this.b.unbindService(this);
          }
        }
        Object localObject = (NotificationManagerCompat.j)parama.d.peek();
        if (localObject != null) {}
        try
        {
          if (Log.isLoggable("NotifManCompat", 3)) {
            new StringBuilder("Sending task ").append(localObject);
          }
          ((NotificationManagerCompat.j)localObject).a(parama.c);
          parama.d.remove();
        }
        catch (DeadObjectException localDeadObjectException)
        {
          if (Log.isLoggable("NotifManCompat", 3)) {
            new StringBuilder("Remote service has died: ").append(parama.a);
          }
          if (parama.d.isEmpty()) {
            continue;
          }
          b(parama);
          return;
        }
        catch (RemoteException localRemoteException)
        {
          for (;;)
          {
            Log.w("NotifManCompat", "RemoteException communicating with " + parama.a, localRemoteException);
          }
        }
      }
    }
    
    public final boolean handleMessage(Message paramMessage)
    {
      Object localObject1;
      switch (paramMessage.what)
      {
      default: 
        return false;
      case 0: 
        paramMessage = (NotificationManagerCompat.j)paramMessage.obj;
        Object localObject2 = NotificationManagerCompat.getEnabledListenerPackages(this.b);
        if (!((Set)localObject2).equals(this.e))
        {
          this.e = ((Set)localObject2);
          Object localObject3 = this.b.getPackageManager().queryIntentServices(new Intent().setAction("android.support.BIND_NOTIFICATION_SIDE_CHANNEL"), 4);
          localObject1 = new HashSet();
          localObject3 = ((List)localObject3).iterator();
          while (((Iterator)localObject3).hasNext())
          {
            ResolveInfo localResolveInfo = (ResolveInfo)((Iterator)localObject3).next();
            if (((Set)localObject2).contains(localResolveInfo.serviceInfo.packageName))
            {
              ComponentName localComponentName = new ComponentName(localResolveInfo.serviceInfo.packageName, localResolveInfo.serviceInfo.name);
              if (localResolveInfo.serviceInfo.permission != null) {
                Log.w("NotifManCompat", "Permission present on component " + localComponentName + ", not adding listener record.");
              } else {
                ((Set)localObject1).add(localComponentName);
              }
            }
          }
          localObject2 = ((Set)localObject1).iterator();
          while (((Iterator)localObject2).hasNext())
          {
            localObject3 = (ComponentName)((Iterator)localObject2).next();
            if (!this.d.containsKey(localObject3))
            {
              if (Log.isLoggable("NotifManCompat", 3)) {
                new StringBuilder("Adding listener record for ").append(localObject3);
              }
              this.d.put(localObject3, new a((ComponentName)localObject3));
            }
          }
          localObject2 = this.d.entrySet().iterator();
          while (((Iterator)localObject2).hasNext())
          {
            localObject3 = (Map.Entry)((Iterator)localObject2).next();
            if (!((Set)localObject1).contains(((Map.Entry)localObject3).getKey()))
            {
              if (Log.isLoggable("NotifManCompat", 3)) {
                new StringBuilder("Removing listener record for ").append(((Map.Entry)localObject3).getKey());
              }
              a((a)((Map.Entry)localObject3).getValue());
              ((Iterator)localObject2).remove();
            }
          }
        }
        localObject1 = this.d.values().iterator();
        while (((Iterator)localObject1).hasNext())
        {
          localObject2 = (a)((Iterator)localObject1).next();
          ((a)localObject2).d.add(paramMessage);
          c((a)localObject2);
        }
        return true;
      case 1: 
        localObject1 = (NotificationManagerCompat.h)paramMessage.obj;
        paramMessage = ((NotificationManagerCompat.h)localObject1).a;
        localObject1 = ((NotificationManagerCompat.h)localObject1).b;
        paramMessage = (a)this.d.get(paramMessage);
        if (paramMessage != null)
        {
          paramMessage.c = INotificationSideChannel.Stub.asInterface((IBinder)localObject1);
          paramMessage.e = 0;
          c(paramMessage);
        }
        return true;
      case 2: 
        paramMessage = (ComponentName)paramMessage.obj;
        paramMessage = (a)this.d.get(paramMessage);
        if (paramMessage != null) {
          a(paramMessage);
        }
        return true;
      }
      paramMessage = (ComponentName)paramMessage.obj;
      paramMessage = (a)this.d.get(paramMessage);
      if (paramMessage != null) {
        c(paramMessage);
      }
      return true;
    }
    
    public final void onServiceConnected(ComponentName paramComponentName, IBinder paramIBinder)
    {
      if (Log.isLoggable("NotifManCompat", 3)) {
        new StringBuilder("Connected to service ").append(paramComponentName);
      }
      this.a.obtainMessage(1, new NotificationManagerCompat.h(paramComponentName, paramIBinder)).sendToTarget();
    }
    
    public final void onServiceDisconnected(ComponentName paramComponentName)
    {
      if (Log.isLoggable("NotifManCompat", 3)) {
        new StringBuilder("Disconnected from service ").append(paramComponentName);
      }
      this.a.obtainMessage(2, paramComponentName).sendToTarget();
    }
    
    static final class a
    {
      public final ComponentName a;
      public boolean b = false;
      public INotificationSideChannel c;
      public LinkedList<NotificationManagerCompat.j> d = new LinkedList();
      public int e = 0;
      
      public a(ComponentName paramComponentName)
      {
        this.a = paramComponentName;
      }
    }
  }
  
  static abstract interface j
  {
    public abstract void a(INotificationSideChannel paramINotificationSideChannel)
      throws RemoteException;
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/android/support/v4/app/NotificationManagerCompat.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */