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.annotation.SystemService; 20 import android.content.Context; 21 import android.net.IEthernetManager; 22 import android.net.IEthernetServiceListener; 23 import android.net.IpConfiguration; 24 import android.os.Handler; 25 import android.os.Message; 26 import android.os.RemoteException; 27 28 import java.util.ArrayList; 29 30 /** 31 * A class representing the IP configuration of the Ethernet network. 32 * 33 * @hide 34 */ 35 @SystemService(Context.ETHERNET_SERVICE) 36 public class EthernetManager { 37 private static final String TAG = "EthernetManager"; 38 private static final int MSG_AVAILABILITY_CHANGED = 1000; 39 40 private final Context mContext; 41 private final IEthernetManager mService; 42 private final Handler mHandler = new Handler() { 43 @Override 44 public void handleMessage(Message msg) { 45 if (msg.what == MSG_AVAILABILITY_CHANGED) { 46 boolean isAvailable = (msg.arg1 == 1); 47 for (Listener listener : mListeners) { 48 listener.onAvailabilityChanged(isAvailable); 49 } 50 } 51 } 52 }; 53 private final ArrayList<Listener> mListeners = new ArrayList<Listener>(); 54 private final IEthernetServiceListener.Stub mServiceListener = 55 new IEthernetServiceListener.Stub() { 56 @Override 57 public void onAvailabilityChanged(boolean isAvailable) { 58 mHandler.obtainMessage( 59 MSG_AVAILABILITY_CHANGED, isAvailable ? 1 : 0, 0, null).sendToTarget(); 60 } 61 }; 62 63 /** 64 * A listener interface to receive notification on changes in Ethernet. 65 */ 66 public interface Listener { 67 /** 68 * Called when Ethernet port's availability is changed. 69 * @param isAvailable {@code true} if one or more Ethernet port exists. 70 */ onAvailabilityChanged(boolean isAvailable)71 public void onAvailabilityChanged(boolean isAvailable); 72 } 73 74 /** 75 * Create a new EthernetManager instance. 76 * Applications will almost always want to use 77 * {@link android.content.Context#getSystemService Context.getSystemService()} to retrieve 78 * the standard {@link android.content.Context#ETHERNET_SERVICE Context.ETHERNET_SERVICE}. 79 */ EthernetManager(Context context, IEthernetManager service)80 public EthernetManager(Context context, IEthernetManager service) { 81 mContext = context; 82 mService = service; 83 } 84 85 /** 86 * Get Ethernet configuration. 87 * @return the Ethernet Configuration, contained in {@link IpConfiguration}. 88 */ getConfiguration()89 public IpConfiguration getConfiguration() { 90 try { 91 return mService.getConfiguration(); 92 } catch (RemoteException e) { 93 throw e.rethrowFromSystemServer(); 94 } 95 } 96 97 /** 98 * Set Ethernet configuration. 99 */ setConfiguration(IpConfiguration config)100 public void setConfiguration(IpConfiguration config) { 101 try { 102 mService.setConfiguration(config); 103 } catch (RemoteException e) { 104 throw e.rethrowFromSystemServer(); 105 } 106 } 107 108 /** 109 * Indicates whether the system currently has one or more 110 * Ethernet interfaces. 111 */ isAvailable()112 public boolean isAvailable() { 113 try { 114 return mService.isAvailable(); 115 } catch (RemoteException e) { 116 throw e.rethrowFromSystemServer(); 117 } 118 } 119 120 /** 121 * Adds a listener. 122 * @param listener A {@link Listener} to add. 123 * @throws IllegalArgumentException If the listener is null. 124 */ addListener(Listener listener)125 public void addListener(Listener listener) { 126 if (listener == null) { 127 throw new IllegalArgumentException("listener must not be null"); 128 } 129 mListeners.add(listener); 130 if (mListeners.size() == 1) { 131 try { 132 mService.addListener(mServiceListener); 133 } catch (RemoteException e) { 134 throw e.rethrowFromSystemServer(); 135 } 136 } 137 } 138 139 /** 140 * Removes a listener. 141 * @param listener A {@link Listener} to remove. 142 * @throws IllegalArgumentException If the listener is null. 143 */ removeListener(Listener listener)144 public void removeListener(Listener listener) { 145 if (listener == null) { 146 throw new IllegalArgumentException("listener must not be null"); 147 } 148 mListeners.remove(listener); 149 if (mListeners.isEmpty()) { 150 try { 151 mService.removeListener(mServiceListener); 152 } catch (RemoteException e) { 153 throw e.rethrowFromSystemServer(); 154 } 155 } 156 } 157 } 158