content: /*
   * Copyright (C) 2017 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.net.lowpan;
  
  import android.annotation.NonNull;
  import android.annotation.Nullable;
  import android.content.Context;
  import android.os.Handler;
  import android.os.IBinder;
  import android.os.Looper;
  import android.os.RemoteException;
  import android.os.ServiceManager;
  import java.lang.ref.WeakReference;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.WeakHashMap;
  
  /**
   * Manager object for looking up LoWPAN interfaces.
   *
   * @hide
   */
  // @SystemApi
  public class LowpanManager {
      private static final String TAG = LowpanManager.class.getSimpleName();
  
      /** @hide */
      // @SystemApi
      public abstract static class Callback {
          public void onInterfaceAdded(LowpanInterface lowpanInterface) {}
  
          public void onInterfaceRemoved(LowpanInterface lowpanInterface) {}
      }
  
      private final Map<Integer, ILowpanManagerListener> mListenerMap = new HashMap<>();
      private final Map<String, LowpanInterface> mInterfaceCache = new HashMap<>();
  
      /* This is a WeakHashMap because we don't want to hold onto
       * a strong reference to ILowpanInterface, so that it can be
       * garbage collected if it isn't being used anymore. Since
       * the value class holds onto this specific ILowpanInterface,
       * we also need to have a weak reference to the value.
       * This design pattern allows us to skip removal of items
       * from this Map without leaking memory.
       */
      private final Map<IBinder, WeakReference<LowpanInterface>> mBinderCache =
              new WeakHashMap<>();
  
      private final ILowpanManager mService;
      private final Context mContext;
      private final Looper mLooper;
  
      // Static Methods
  
      public static LowpanManager from(Context context) {
          return (LowpanManager) context.getSystemService(Context.LOWPAN_SERVICE);
      }
  
      /** @hide */
      public static LowpanManager getManager() {
          IBinder binder = ServiceManager.getService(Context.LOWPAN_SERVICE);
  
          if (binder != null) {
              ILowpanManager service = ILowpanManager.Stub.asInterface(binder);
              return new LowpanManager(service);
          }
  
          return null;
      }
  
      // Constructors
  
      LowpanManager(ILowpanManager service) {
          mService = service;
          mContext = null;
          mLooper = null;
      }
  
      /**
       * Create a new LowpanManager instance. Applications will almost always want to use {@link
       * android.content.Context#getSystemService Context.getSystemService()} to retrieve the standard
       * {@link android.content.Context#LOWPAN_SERVICE Context.LOWPAN_SERVICE}.
       *
       * @param context the application context
       * @param service the Binder interface
       * @param looper the default Looper to run callbacks on
       * @hide - hide this because it takes in a parameter of type ILowpanManager, which is a system
       *     private class.
       */
      public LowpanManager(Context context, ILowpanManager service, Looper looper) {
          mContext = context;
          mService = service;
          mLooper = looper;
      }
  
      /** @hide */
      @Nullable
      public LowpanInterface getInterfaceNoCreate(@NonNull ILowpanInterface ifaceService) {
          LowpanInterface iface = null;
  
          synchronized (mBinderCache) {
              if (mBinderCache.containsKey(ifaceService.asBinder())) {
                  iface = mBinderCache.get(ifaceService.asBinder()).get();
              }
          }
  
          return iface;
      }
  
      /** @hide */
      @Nullable
      public LowpanInterface getInterface(@NonNull ILowpanInterface ifaceService) {
          LowpanInterface iface = null;
  
          try {
              synchronized (mBinderCache) {
                  if (mBinderCache.containsKey(ifaceService.asBinder())) {
                      iface = mBinderCache.get(ifaceService.asBinder()).get();
                  }
  
                  if (iface == null) {
                      String ifaceName = ifaceService.getName();
  
                      iface = new LowpanInterface(mContext, ifaceService, mLooper);
  
                      synchronized (mInterfaceCache) {
                          mInterfaceCache.put(iface.getName(), iface);
                      }
  
                      mBinderCache.put(ifaceService.asBinder(), new WeakReference(iface));
  
                      /* Make sure we remove the object from the
                       * interface cache if the associated service
                       * dies.
                       */
                      ifaceService
                              .asBinder()
                              .linkToDeath(
                                      new IBinder.DeathRecipient() {
                                          @Override
                                          public void binderDied() {
                                              synchronized (mInterfaceCache) {
                                                  LowpanInterface iface =
                                                          mInterfaceCache.get(ifaceName);
  
                                                  if ((iface != null)
                                                          && (iface.getService() == ifaceService)) {
                                                      mInterfaceCache.remove(ifaceName);
                                                  }
                                              }
                                          }
                                      },
                                      0);
                  }
              }
          } catch (RemoteException x) {
              throw x.rethrowAsRuntimeException();
          }
  
          return iface;
      }
  
      /**
       * Returns a reference to the requested LowpanInterface object. If the given interface doesn't
       * exist, or it is not a LoWPAN interface, returns null.
       */
      @Nullable
      public LowpanInterface getInterface(@NonNull String name) {
          LowpanInterface iface = null;
  
          try {
              /* This synchronized block covers both branches of the enclosed
               * if() statement in order to avoid a race condition. Two threads
               * calling getInterface() with the same name would race to create
               * the associated LowpanInterface object, creating two of them.
               * Having the whole block be synchronized avoids that race.
               */
              synchronized (mInterfaceCache) {
                  if (mInterfaceCache.containsKey(name)) {
                      iface = mInterfaceCache.get(name);
  
                  } else {
                      ILowpanInterface ifaceService = mService.getInterface(name);
  
                      if (ifaceService != null) {
                          iface = getInterface(ifaceService);
                      }
                  }
              }
          } catch (RemoteException x) {
              throw x.rethrowFromSystemServer();
          }
  
          return iface;
      }
  
      /**
       * Returns a reference to the first registered LowpanInterface object. If there are no LoWPAN
       * interfaces registered, returns null.
       */
      @Nullable
      public LowpanInterface getInterface() {
          String[] ifaceList = getInterfaceList();
          if (ifaceList.length > 0) {
              return getInterface(ifaceList[0]);
          }
          return null;
      }
  
      /**
       * Returns a string array containing the names of LoWPAN interfaces. This list may contain fewer
       * interfaces if the calling process does not have permissions to see individual interfaces.
       */
      @NonNull
      public String[] getInterfaceList() {
          try {
              return mService.getInterfaceList();
          } catch (RemoteException x) {
              throw x.rethrowFromSystemServer();
          }
      }
  
      /**
       * Registers a callback object to receive notifications when LoWPAN interfaces are added or
       * removed.
       *
       * @hide
       */
      public void registerCallback(@NonNull Callback cb, @Nullable Handler handler)
              throws LowpanException {
          ILowpanManagerListener.Stub listenerBinder =
                  new ILowpanManagerListener.Stub() {
                      private Handler mHandler;
  
                      {
                          if (handler != null) {
                              mHandler = handler;
                          } else if (mLooper != null) {
                              mHandler = new Handler(mLooper);
                          } else {
                              mHandler = new Handler();
                          }
                      }
  
                      @Override
                      public void onInterfaceAdded(ILowpanInterface ifaceService) {
                          Runnable runnable =
                                  () -> {
                                      LowpanInterface iface = getInterface(ifaceService);
  
                                      if (iface != null) {
                                          cb.onInterfaceAdded(iface);
                                      }
                                  };
  
                          mHandler.post(runnable);
                      }
  
                      @Override
                      public void onInterfaceRemoved(ILowpanInterface ifaceService) {
                          Runnable runnable =
                                  () -> {
                                      LowpanInterface iface = getInterfaceNoCreate(ifaceService);
  
                                      if (iface != null) {
                                          cb.onInterfaceRemoved(iface);
                                      }
                                  };
  
                          mHandler.post(runnable);
                      }
                  };
          try {
              mService.addListener(listenerBinder);
          } catch (RemoteException x) {
              throw x.rethrowFromSystemServer();
          }
  
          synchronized (mListenerMap) {
              mListenerMap.put(Integer.valueOf(System.identityHashCode(cb)), listenerBinder);
          }
      }
  
      /** @hide */
      public void registerCallback(@NonNull Callback cb) throws LowpanException {
          registerCallback(cb, null);
      }
  
      /**
       * Unregisters a previously registered {@link LowpanManager.Callback} object.
       *
       * @hide
       */
      public void unregisterCallback(@NonNull Callback cb) {
          Integer hashCode = Integer.valueOf(System.identityHashCode(cb));
          ILowpanManagerListener listenerBinder = null;
  
          synchronized (mListenerMap) {
              listenerBinder = mListenerMap.get(hashCode);
              mListenerMap.remove(hashCode);
          }
  
          if (listenerBinder != null) {
              try {
                  mService.removeListener(listenerBinder);
              } catch (RemoteException x) {
                  throw x.rethrowFromSystemServer();
              }
          } else {
              throw new RuntimeException("Attempt to unregister an unknown callback");
          }
      }
  }
  