341 lines
11 KiB
Java
341 lines
11 KiB
Java
/*
|
|
* Copyright (C) 2014 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 com.android.internal.telephony;
|
|
|
|
import android.content.res.Resources;
|
|
import android.os.AsyncResult;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
|
|
import com.android.telephony.Rlog;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* TelephonyDevController - provides a unified view of the
|
|
* telephony hardware resources on a device.
|
|
*
|
|
* manages the set of HardwareConfig for the framework.
|
|
*/
|
|
public class TelephonyDevController extends Handler {
|
|
private static final String LOG_TAG = "TDC";
|
|
private static final boolean DBG = true;
|
|
private static final Object mLock = new Object();
|
|
|
|
private static final int EVENT_HARDWARE_CONFIG_CHANGED = 1;
|
|
|
|
private static TelephonyDevController sTelephonyDevController;
|
|
private static ArrayList<HardwareConfig> mModems = new ArrayList<HardwareConfig>();
|
|
private static ArrayList<HardwareConfig> mSims = new ArrayList<HardwareConfig>();
|
|
|
|
private static Message sRilHardwareConfig;
|
|
|
|
private static void logd(String s) {
|
|
Rlog.d(LOG_TAG, s);
|
|
}
|
|
|
|
private static void loge(String s) {
|
|
Rlog.e(LOG_TAG, s);
|
|
}
|
|
|
|
/** Create TelephonyDevController and set as singleton instance. */
|
|
public static TelephonyDevController create() {
|
|
synchronized (mLock) {
|
|
if (sTelephonyDevController != null) {
|
|
throw new RuntimeException("TelephonyDevController already created!?!");
|
|
}
|
|
sTelephonyDevController = new TelephonyDevController();
|
|
return sTelephonyDevController;
|
|
}
|
|
}
|
|
|
|
/** Get TelephonyDevController singleton. */
|
|
public static TelephonyDevController getInstance() {
|
|
synchronized (mLock) {
|
|
if (sTelephonyDevController == null) {
|
|
throw new RuntimeException("TelephonyDevController not yet created!?!");
|
|
}
|
|
return sTelephonyDevController;
|
|
}
|
|
}
|
|
|
|
private void initFromResource() {
|
|
Resources resource = Resources.getSystem();
|
|
String[] hwStrings = resource.getStringArray(
|
|
com.android.internal.R.array.config_telephonyHardware);
|
|
if (hwStrings != null) {
|
|
for (String hwString : hwStrings) {
|
|
HardwareConfig hw = new HardwareConfig(hwString);
|
|
if (hw != null) {
|
|
if (hw.type == HardwareConfig.DEV_HARDWARE_TYPE_MODEM) {
|
|
updateOrInsert(hw, mModems);
|
|
} else if (hw.type == HardwareConfig.DEV_HARDWARE_TYPE_SIM) {
|
|
updateOrInsert(hw, mSims);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private TelephonyDevController() {
|
|
initFromResource();
|
|
|
|
mModems.trimToSize();
|
|
mSims.trimToSize();
|
|
}
|
|
|
|
/**
|
|
* each RIL call this interface to register/unregister the unsolicited hardware
|
|
* configuration callback data it can provide.
|
|
*/
|
|
public static void registerRIL(CommandsInterface cmdsIf) {
|
|
/* get the current configuration from this ril... */
|
|
cmdsIf.getHardwareConfig(sRilHardwareConfig);
|
|
/* ... process it ... */
|
|
if (sRilHardwareConfig != null) {
|
|
AsyncResult ar = (AsyncResult) sRilHardwareConfig.obj;
|
|
if (ar.exception == null) {
|
|
handleGetHardwareConfigChanged(ar);
|
|
}
|
|
}
|
|
/* and register for async device configuration change. */
|
|
cmdsIf.registerForHardwareConfigChanged(sTelephonyDevController, EVENT_HARDWARE_CONFIG_CHANGED, null);
|
|
}
|
|
|
|
public static void unregisterRIL(CommandsInterface cmdsIf) {
|
|
cmdsIf.unregisterForHardwareConfigChanged(sTelephonyDevController);
|
|
}
|
|
|
|
/**
|
|
* handle callbacks from RIL.
|
|
*/
|
|
public void handleMessage(Message msg) {
|
|
AsyncResult ar;
|
|
switch (msg.what) {
|
|
case EVENT_HARDWARE_CONFIG_CHANGED:
|
|
if (DBG) logd("handleMessage: received EVENT_HARDWARE_CONFIG_CHANGED");
|
|
ar = (AsyncResult) msg.obj;
|
|
handleGetHardwareConfigChanged(ar);
|
|
break;
|
|
default:
|
|
loge("handleMessage: Unknown Event " + msg.what);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* hardware configuration update or insert.
|
|
*/
|
|
private static void updateOrInsert(HardwareConfig hw, ArrayList<HardwareConfig> list) {
|
|
int size;
|
|
HardwareConfig item;
|
|
synchronized (mLock) {
|
|
size = list.size();
|
|
for (int i = 0 ; i < size ; i++) {
|
|
item = list.get(i);
|
|
if (item.uuid.compareTo(hw.uuid) == 0) {
|
|
if (DBG) logd("updateOrInsert: removing: " + item);
|
|
list.remove(i);
|
|
break;
|
|
}
|
|
}
|
|
if (DBG) logd("updateOrInsert: inserting: " + hw);
|
|
list.add(hw);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* hardware configuration changed.
|
|
*/
|
|
private static void handleGetHardwareConfigChanged(AsyncResult ar) {
|
|
if ((ar.exception == null) && (ar.result != null)) {
|
|
List hwcfg = (List)ar.result;
|
|
for (int i = 0 ; i < hwcfg.size() ; i++) {
|
|
HardwareConfig hw = null;
|
|
|
|
hw = (HardwareConfig) hwcfg.get(i);
|
|
if (hw != null) {
|
|
if (hw.type == HardwareConfig.DEV_HARDWARE_TYPE_MODEM) {
|
|
updateOrInsert(hw, mModems);
|
|
} else if (hw.type == HardwareConfig.DEV_HARDWARE_TYPE_SIM) {
|
|
updateOrInsert(hw, mSims);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
/* error detected, ignore. are we missing some real time configutation
|
|
* at this point? what to do...
|
|
*/
|
|
loge("handleGetHardwareConfigChanged - returned an error.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get total number of registered modem.
|
|
*/
|
|
public static int getModemCount() {
|
|
synchronized (mLock) {
|
|
int count = mModems.size();
|
|
if (DBG) logd("getModemCount: " + count);
|
|
return count;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get modem at index 'index'.
|
|
*/
|
|
public HardwareConfig getModem(int index) {
|
|
synchronized (mLock) {
|
|
if (mModems.isEmpty()) {
|
|
loge("getModem: no registered modem device?!?");
|
|
return null;
|
|
}
|
|
|
|
if (index > getModemCount()) {
|
|
loge("getModem: out-of-bounds access for modem device " + index + " max: " + getModemCount());
|
|
return null;
|
|
}
|
|
|
|
if (DBG) logd("getModem: " + index);
|
|
return mModems.get(index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get total number of registered sims.
|
|
*/
|
|
public int getSimCount() {
|
|
synchronized (mLock) {
|
|
int count = mSims.size();
|
|
if (DBG) logd("getSimCount: " + count);
|
|
return count;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get sim at index 'index'.
|
|
*/
|
|
public HardwareConfig getSim(int index) {
|
|
synchronized (mLock) {
|
|
if (mSims.isEmpty()) {
|
|
loge("getSim: no registered sim device?!?");
|
|
return null;
|
|
}
|
|
|
|
if (index > getSimCount()) {
|
|
loge("getSim: out-of-bounds access for sim device " + index + " max: " + getSimCount());
|
|
return null;
|
|
}
|
|
|
|
if (DBG) logd("getSim: " + index);
|
|
return mSims.get(index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get modem associated with sim index 'simIndex'.
|
|
*/
|
|
public HardwareConfig getModemForSim(int simIndex) {
|
|
synchronized (mLock) {
|
|
if (mModems.isEmpty() || mSims.isEmpty()) {
|
|
loge("getModemForSim: no registered modem/sim device?!?");
|
|
return null;
|
|
}
|
|
|
|
if (simIndex > getSimCount()) {
|
|
loge("getModemForSim: out-of-bounds access for sim device " + simIndex + " max: " + getSimCount());
|
|
return null;
|
|
}
|
|
|
|
if (DBG) logd("getModemForSim " + simIndex);
|
|
|
|
HardwareConfig sim = getSim(simIndex);
|
|
for (HardwareConfig modem: mModems) {
|
|
if (modem.uuid.equals(sim.modemUuid)) {
|
|
return modem;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get all sim's associated with modem at index 'modemIndex'.
|
|
*/
|
|
public ArrayList<HardwareConfig> getAllSimsForModem(int modemIndex) {
|
|
synchronized (mLock) {
|
|
if (mSims.isEmpty()) {
|
|
loge("getAllSimsForModem: no registered sim device?!?");
|
|
return null;
|
|
}
|
|
|
|
if (modemIndex > getModemCount()) {
|
|
loge("getAllSimsForModem: out-of-bounds access for modem device " + modemIndex + " max: " + getModemCount());
|
|
return null;
|
|
}
|
|
|
|
if (DBG) logd("getAllSimsForModem " + modemIndex);
|
|
|
|
ArrayList<HardwareConfig> result = new ArrayList<HardwareConfig>();
|
|
HardwareConfig modem = getModem(modemIndex);
|
|
for (HardwareConfig sim: mSims) {
|
|
if (sim.modemUuid.equals(modem.uuid)) {
|
|
result.add(sim);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get all modem's registered.
|
|
*/
|
|
public ArrayList<HardwareConfig> getAllModems() {
|
|
synchronized (mLock) {
|
|
ArrayList<HardwareConfig> modems = new ArrayList<HardwareConfig>();
|
|
if (mModems.isEmpty()) {
|
|
if (DBG) logd("getAllModems: empty list.");
|
|
} else {
|
|
for (HardwareConfig modem: mModems) {
|
|
modems.add(modem);
|
|
}
|
|
}
|
|
|
|
return modems;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get all sim's registered.
|
|
*/
|
|
public ArrayList<HardwareConfig> getAllSims() {
|
|
synchronized (mLock) {
|
|
ArrayList<HardwareConfig> sims = new ArrayList<HardwareConfig>();
|
|
if (mSims.isEmpty()) {
|
|
if (DBG) logd("getAllSims: empty list.");
|
|
} else {
|
|
for (HardwareConfig sim: mSims) {
|
|
sims.add(sim);
|
|
}
|
|
}
|
|
|
|
return sims;
|
|
}
|
|
}
|
|
}
|