core/java/android/net/EthernetManager.java

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.net;
  18
  19 import android.content.Context;
  20 import android.net.IEthernetManager;
  21 import android.net.IEthernetServiceListener;
  22 import android.net.IpConfiguration;
  23 import android.os.Handler;
  24 import android.os.Message;
  25 import android.os.RemoteException;
  26
  27 import java.util.ArrayList;
  28
  29 /**
  30  * A class representing the IP configuration of the Ethernet network.
  31  *
  32  * @hide
  33  */
  34 public class EthernetManager {
  35     private static final String TAG = "EthernetManager";
  36     private static final int MSG_AVAILABILITY_CHANGED = 1000;
  37
  38     private final Context mContext;
  39     private final IEthernetManager mService;
  40     private final Handler mHandler = new Handler() {
  41         @Override
  42         public void handleMessage(Message msg) {
  43             if (msg.what == MSG_AVAILABILITY_CHANGED) {
  44                 boolean isAvailable = (msg.arg1 == 1);
  45                 for (Listener listener : mListeners) {
  46                     listener.onAvailabilityChanged(isAvailable);
  47                 }
  48             }
  49         }
  50     };
  51     private final ArrayList<Listener> mListeners = new ArrayList<Listener>();
  52     private final IEthernetServiceListener.Stub mServiceListener =
  53             new IEthernetServiceListener.Stub() {
  54                 @Override
  55                 public void onAvailabilityChanged(boolean isAvailable) {
  56                     mHandler.obtainMessage(
  57                             MSG_AVAILABILITY_CHANGED, isAvailable ? 1 : 0, 0, null).sendToTarget();
  58                 }
  59             };
  60
  61     /**
  62      * A listener interface to receive notification on changes in Ethernet.
  63      */
  64     public interface Listener {
  65         /**
  66          * Called when Ethernet port's availability is changed.
  67          * @param isAvailable {@code true} if one or more Ethernet port exists.
  68          */
  69         public void onAvailabilityChanged(boolean isAvailable);
  70     }
  71
  72     /**
  73      * Create a new EthernetManager instance.
  74      * Applications will almost always want to use
  75      * {@link android.content.Context#getSystemService Context.getSystemService()} to retrieve
  76      * the standard {@link android.content.Context#ETHERNET_SERVICE Context.ETHERNET_SERVICE}.
  77      */
  78     public EthernetManager(Context context, IEthernetManager service) {
  79         mContext = context;
  80         mService = service;
  81     }
  82
  83     /**
  84      * Get Ethernet configuration.
  85      * @return the Ethernet Configuration, contained in {@link IpConfiguration}.
  86      */
  87     public IpConfiguration getConfiguration() {
  88         try {
  89             return mService.getConfiguration();
  90         } catch (RemoteException e) {
  91             throw e.rethrowFromSystemServer();
  92         }
  93     }
  94
  95     /**
  96      * Set Ethernet configuration.
  97      */
  98     public void setConfiguration(IpConfiguration config) {
  99         try {
 100             mService.setConfiguration(config);
 101         } catch (RemoteException e) {
 102             throw e.rethrowFromSystemServer();
 103         }
 104     }
 105
 106     /**
 107      * Indicates whether the system currently has one or more
 108      * Ethernet interfaces.
 109      */
 110     public boolean isAvailable() {
 111         try {
 112             return mService.isAvailable();
 113         } catch (RemoteException e) {
 114             throw e.rethrowFromSystemServer();
 115         }
 116     }
 117
 118     /**
 119      * Adds a listener.
 120      * @param listener A {@link Listener} to add.
 121      * @throws IllegalArgumentException If the listener is null.
 122      */
 123     public void addListener(Listener listener) {
 124         if (listener == null) {
 125             throw new IllegalArgumentException("listener must not be null");
 126         }
 127         mListeners.add(listener);
 128         if (mListeners.size() == 1) {
 129             try {
 130                 mService.addListener(mServiceListener);
 131             } catch (RemoteException e) {
 132                 throw e.rethrowFromSystemServer();
 133             }
 134         }
 135     }
 136
 137     /**
 138      * Removes a listener.
 139      * @param listener A {@link Listener} to remove.
 140      * @throws IllegalArgumentException If the listener is null.
 141      */
 142     public void removeListener(Listener listener) {
 143         if (listener == null) {
 144             throw new IllegalArgumentException("listener must not be null");
 145         }
 146         mListeners.remove(listener);
 147         if (mListeners.isEmpty()) {
 148             try {
 149                 mService.removeListener(mServiceListener);
 150             } catch (RemoteException e) {
 151                 throw e.rethrowFromSystemServer();
 152             }
 153         }
 154     }
 155 }