Merge "Fix the synchronization pattern in IccSmsInterfaceManager." am:... (dcce143c) · Commits · e / os / android_frameworks_opt_telephony

src/java/com/android/internal/telephony/IccSmsInterfaceManager.java

+116 −141

Original line number	Original line	Diff line number	Diff line
	@@ -59,6 +59,7 @@ import java.io.PrintWriter;
	import java.util.ArrayList;		import java.util.ArrayList;
	import java.util.Arrays;		import java.util.Arrays;
	import java.util.List;		import java.util.List;
			import java.util.concurrent.atomic.AtomicBoolean;

	/**		/**
	* IccSmsInterfaceManager to provide an inter-process communication to		* IccSmsInterfaceManager to provide an inter-process communication to
	@@ -68,15 +69,6 @@ public class IccSmsInterfaceManager {
	static final String LOG_TAG = "IccSmsInterfaceManager";		static final String LOG_TAG = "IccSmsInterfaceManager";
	static final boolean DBG = true;		static final boolean DBG = true;

	@UnsupportedAppUsage
	protected final Object mLock = new Object();
	@UnsupportedAppUsage
	protected boolean mSuccess;
	@UnsupportedAppUsage
	private List<SmsRawData> mSms;

	private String mSmsc;

	@UnsupportedAppUsage		@UnsupportedAppUsage
	private CellBroadcastRangeManager mCellBroadcastRangeManager =		private CellBroadcastRangeManager mCellBroadcastRangeManager =
	new CellBroadcastRangeManager();		new CellBroadcastRangeManager();
	@@ -106,75 +98,80 @@ public class IccSmsInterfaceManager {

	private final LocalLog mCellBroadcastLocalLog = new LocalLog(100);		private final LocalLog mCellBroadcastLocalLog = new LocalLog(100);

			private static final class Request {
			AtomicBoolean mStatus = new AtomicBoolean(false);
			Object mResult = null;
			}

	@UnsupportedAppUsage		@UnsupportedAppUsage
	protected Handler mHandler = new Handler() {		protected Handler mHandler = new Handler() {
	@Override		@Override
	public void handleMessage(Message msg) {		public void handleMessage(Message msg) {
	AsyncResult ar;		AsyncResult ar = (AsyncResult) msg.obj;
			Request request = (Request) ar.userObj;

	switch (msg.what) {		switch (msg.what) {
	case EVENT_UPDATE_DONE:		case EVENT_UPDATE_DONE:
	ar = (AsyncResult) msg.obj;		case EVENT_SET_BROADCAST_ACTIVATION_DONE:
	synchronized (mLock) {		case EVENT_SET_BROADCAST_CONFIG_DONE:
	mSuccess = (ar.exception == null);		case EVENT_SET_SMSC_DONE:
	mLock.notifyAll();		notifyPending(request, ar.exception == null);
	}
	break;		break;
	case EVENT_LOAD_DONE:		case EVENT_LOAD_DONE:
	ar = (AsyncResult)msg.obj;		List<SmsRawData> smsRawDataList = null;
	synchronized (mLock) {
	if (ar.exception == null) {		if (ar.exception == null) {
	mSms = buildValidRawData((ArrayList<byte[]>) ar.result);		smsRawDataList = buildValidRawData((ArrayList<byte[]>) ar.result);
	//Mark SMS as read after importing it from card.		//Mark SMS as read after importing it from card.
	markMessagesAsRead((ArrayList<byte[]>) ar.result);		markMessagesAsRead((ArrayList<byte[]>) ar.result);
	} else {		} else {
	if (Rlog.isLoggable("SMS", Log.DEBUG)) {		if (Rlog.isLoggable("SMS", Log.DEBUG)) {
	loge("Cannot load Sms records");		loge("Cannot load Sms records");
	}		}
	mSms = null;
	}
	mLock.notifyAll();
	}
	break;
	case EVENT_SET_BROADCAST_ACTIVATION_DONE:
	case EVENT_SET_BROADCAST_CONFIG_DONE:
	ar = (AsyncResult) msg.obj;
	synchronized (mLock) {
	mSuccess = (ar.exception == null);
	mLock.notifyAll();
	}		}
			notifyPending(request, smsRawDataList);
	break;		break;
	case EVENT_GET_SMSC_DONE:		case EVENT_GET_SMSC_DONE:
	ar = (AsyncResult) msg.obj;		String smsc = null;
	synchronized (mLock) {
	if (ar.exception == null) {		if (ar.exception == null) {
	mSmsc = (String) ar.result;		smsc = (String) ar.result;
	} else {		} else {
	loge("Cannot read SMSC");		loge("Cannot read SMSC");
	mSmsc = null;
	}
	mLock.notifyAll();
	}		}
			notifyPending(request, smsc);
	break;		break;
	case EVENT_SET_SMSC_DONE:
	ar = (AsyncResult) msg.obj;
	synchronized (mLock) {
	mSuccess = (ar.exception == null);
	mLock.notifyAll();
	}		}
	break;		}

			private void notifyPending(Request request, Object result) {
			if (request != null) {
			synchronized (request) {
			request.mResult = result;
			request.mStatus.set(true);
			request.notifyAll();
			}
	}		}
	}		}
	};		};

	protected IccSmsInterfaceManager(Phone phone) {		protected IccSmsInterfaceManager(Phone phone) {
	mPhone = phone;		this(phone, phone.getContext(),
	mContext = phone.getContext();		(AppOpsManager) phone.getContext().getSystemService(Context.APP_OPS_SERVICE),
	mAppOps = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
	mDispatchersController =
	new SmsDispatchersController(		new SmsDispatchersController(
	phone, phone.mSmsStorageMonitor, phone.mSmsUsageMonitor);		phone, phone.mSmsStorageMonitor, phone.mSmsUsageMonitor),
	mSmsPermissions = new SmsPermissions(phone, mContext, mAppOps);		new SmsPermissions(phone, phone.getContext(),
			(AppOpsManager) phone.getContext().getSystemService(
			Context.APP_OPS_SERVICE)));
			}

			@VisibleForTesting
			public IccSmsInterfaceManager(
			Phone phone, Context context, AppOpsManager appOps,
			SmsDispatchersController dispatchersController, SmsPermissions smsPermissions) {
			mPhone = phone;
			mContext = context;
			mAppOps = appOps;
			mDispatchersController = dispatchersController;
			mSmsPermissions = smsPermissions;
	}		}

	private void enforceNotOnHandlerThread(String methodName) {		private void enforceNotOnHandlerThread(String methodName) {
	@@ -258,9 +255,9 @@ public class IccSmsInterfaceManager {
	callingPackage) != AppOpsManager.MODE_ALLOWED) {		callingPackage) != AppOpsManager.MODE_ALLOWED) {
	return false;		return false;
	}		}
	synchronized(mLock) {		Request updateRequest = new Request();
	mSuccess = false;		synchronized (updateRequest) {
	Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE);		Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE, updateRequest);

	if ((status & 0x01) == STATUS_ON_ICC_FREE) {		if ((status & 0x01) == STATUS_ON_ICC_FREE) {
	// RIL_REQUEST_DELETE_SMS_ON_SIM vs RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM		// RIL_REQUEST_DELETE_SMS_ON_SIM vs RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM
	@@ -277,20 +274,16 @@ public class IccSmsInterfaceManager {
	IccFileHandler fh = mPhone.getIccFileHandler();		IccFileHandler fh = mPhone.getIccFileHandler();
	if (fh == null) {		if (fh == null) {
	response.recycle();		response.recycle();
	return mSuccess; /* is false */		return false; /* is false */
	}		}
	byte[] record = makeSmsRecordData(status, pdu);		byte[] record = makeSmsRecordData(status, pdu);
	fh.updateEFLinearFixed(		fh.updateEFLinearFixed(
	IccConstants.EF_SMS,		IccConstants.EF_SMS,
	index, record, null, response);		index, record, null, response);
	}		}
	try {		waitForResult(updateRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to update by index");
	}
	}		}
	return mSuccess;		return (boolean) updateRequest.mResult;
	}		}

	/**		/**
	@@ -318,9 +311,9 @@ public class IccSmsInterfaceManager {
	callingPackage) != AppOpsManager.MODE_ALLOWED) {		callingPackage) != AppOpsManager.MODE_ALLOWED) {
	return false;		return false;
	}		}
	synchronized(mLock) {		Request copyRequest = new Request();
	mSuccess = false;		synchronized (copyRequest) {
	Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE);		Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE, copyRequest);

	//RIL_REQUEST_WRITE_SMS_TO_SIM vs RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM		//RIL_REQUEST_WRITE_SMS_TO_SIM vs RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM
	if (PhoneConstants.PHONE_TYPE_GSM == mPhone.getPhoneType()) {		if (PhoneConstants.PHONE_TYPE_GSM == mPhone.getPhoneType()) {
	@@ -330,13 +323,9 @@ public class IccSmsInterfaceManager {
	mPhone.mCi.writeSmsToRuim(status, pdu, response);		mPhone.mCi.writeSmsToRuim(status, pdu, response);
	}		}

	try {		waitForResult(copyRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to update by index");
	}		}
	}		return (boolean) copyRequest.mResult;
	return mSuccess;
	}		}

	/**		/**
	@@ -358,25 +347,21 @@ public class IccSmsInterfaceManager {
	callingPackage) != AppOpsManager.MODE_ALLOWED) {		callingPackage) != AppOpsManager.MODE_ALLOWED) {
	return new ArrayList<SmsRawData>();		return new ArrayList<SmsRawData>();
	}		}
	synchronized(mLock) {		Request getRequest = new Request();
			synchronized (getRequest) {

	IccFileHandler fh = mPhone.getIccFileHandler();		IccFileHandler fh = mPhone.getIccFileHandler();
	if (fh == null) {		if (fh == null) {
	loge("Cannot load Sms records. No icc card?");		loge("Cannot load Sms records. No icc card?");
	mSms = null;		return null;
	return mSms;
	}		}

	Message response = mHandler.obtainMessage(EVENT_LOAD_DONE);		Message response = mHandler.obtainMessage(EVENT_LOAD_DONE, getRequest);
	fh.loadEFLinearFixedAll(IccConstants.EF_SMS, response);		fh.loadEFLinearFixedAll(IccConstants.EF_SMS, response);

	try {		waitForResult(getRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to load from the Icc");
	}		}
	}		return (List<SmsRawData>) getRequest.mResult;
	return mSms;
	}		}

	/**		/**
	@@ -878,17 +863,13 @@ public class IccSmsInterfaceManager {
	return null;		return null;
	}		}
	enforceNotOnHandlerThread("getSmscAddressFromIccEf");		enforceNotOnHandlerThread("getSmscAddressFromIccEf");
	synchronized (mLock) {		Request getRequest = new Request();
	mSmsc = null;		synchronized (getRequest) {
	Message response = mHandler.obtainMessage(EVENT_GET_SMSC_DONE);		Message response = mHandler.obtainMessage(EVENT_GET_SMSC_DONE, getRequest);
	mPhone.mCi.getSmscAddress(response);		mPhone.mCi.getSmscAddress(response);
	try {		waitForResult(getRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to read SMSC");
	}
	}		}
	return mSmsc;		return (String) getRequest.mResult;
	}		}

	/**		/**
	@@ -902,17 +883,14 @@ public class IccSmsInterfaceManager {
	callingPackage, "setSmscAddressOnIccEf")) {		callingPackage, "setSmscAddressOnIccEf")) {
	return false;		return false;
	}		}
	synchronized (mLock) {		enforceNotOnHandlerThread("setSmscAddressOnIccEf");
	mSuccess = false;		Request setRequest = new Request();
	Message response = mHandler.obtainMessage(EVENT_SET_SMSC_DONE);		synchronized (setRequest) {
			Message response = mHandler.obtainMessage(EVENT_SET_SMSC_DONE, setRequest);
	mPhone.mCi.setSmscAddress(smsc, response);		mPhone.mCi.setSmscAddress(smsc, response);
	try {		waitForResult(setRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to write SMSC");
	}		}
	}		return (boolean) setRequest.mResult;
	return mSuccess;
	}		}

	public boolean enableCellBroadcast(int messageIdentifier, int ranType) {		public boolean enableCellBroadcast(int messageIdentifier, int ranType) {
	@@ -1164,20 +1142,16 @@ public class IccSmsInterfaceManager {
	log("Calling setGsmBroadcastConfig with " + configs.length + " configurations");		log("Calling setGsmBroadcastConfig with " + configs.length + " configurations");
	}		}
	enforceNotOnHandlerThread("setCellBroadcastConfig");		enforceNotOnHandlerThread("setCellBroadcastConfig");
	synchronized (mLock) {		Request setRequest = new Request();
	Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_CONFIG_DONE);		synchronized (setRequest) {
			Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_CONFIG_DONE, setRequest);

	mSuccess = false;
	mPhone.mCi.setGsmBroadcastConfig(configs, response);		mPhone.mCi.setGsmBroadcastConfig(configs, response);

	try {		waitForResult(setRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to set cell broadcast config");
	}
	}		}

	return mSuccess;		return (boolean) setRequest.mResult;
	}		}

	private boolean setCellBroadcastActivation(boolean activate) {		private boolean setCellBroadcastActivation(boolean activate) {
	@@ -1186,20 +1160,16 @@ public class IccSmsInterfaceManager {
	}		}

	enforceNotOnHandlerThread("setCellBroadcastConfig");		enforceNotOnHandlerThread("setCellBroadcastConfig");
	synchronized (mLock) {		Request setRequest = new Request();
	Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_ACTIVATION_DONE);		synchronized (setRequest) {
			Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_ACTIVATION_DONE,
			setRequest);

	mSuccess = false;
	mPhone.mCi.setGsmBroadcastActivation(activate, response);		mPhone.mCi.setGsmBroadcastActivation(activate, response);
			waitForResult(setRequest);
	try {
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to set cell broadcast activation");
	}
	}		}

	return mSuccess;		return (boolean) setRequest.mResult;
	}		}

	@UnsupportedAppUsage		@UnsupportedAppUsage
	@@ -1209,20 +1179,16 @@ public class IccSmsInterfaceManager {
	}		}

	enforceNotOnHandlerThread("setCdmaBroadcastConfig");		enforceNotOnHandlerThread("setCdmaBroadcastConfig");
	synchronized (mLock) {		Request setRequest = new Request();
	Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_CONFIG_DONE);		synchronized (setRequest) {
			Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_CONFIG_DONE, setRequest);

	mSuccess = false;
	mPhone.mCi.setCdmaBroadcastConfig(configs, response);		mPhone.mCi.setCdmaBroadcastConfig(configs, response);

	try {		waitForResult(setRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to set cdma broadcast config");
	}
	}		}

	return mSuccess;		return (boolean) setRequest.mResult;
	}		}

	private boolean setCdmaBroadcastActivation(boolean activate) {		private boolean setCdmaBroadcastActivation(boolean activate) {
	@@ -1231,20 +1197,17 @@ public class IccSmsInterfaceManager {
	}		}

	enforceNotOnHandlerThread("setCdmaBroadcastActivation");		enforceNotOnHandlerThread("setCdmaBroadcastActivation");
	synchronized (mLock) {		Request setRequest = new Request();
	Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_ACTIVATION_DONE);		synchronized (setRequest) {
			Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_ACTIVATION_DONE,
			setRequest);

	mSuccess = false;
	mPhone.mCi.setCdmaBroadcastActivation(activate, response);		mPhone.mCi.setCdmaBroadcastActivation(activate, response);

	try {		waitForResult(setRequest);
	mLock.wait();
	} catch (InterruptedException e) {
	loge("interrupted while trying to set cdma broadcast activation");
	}
	}		}

	return mSuccess;		return (boolean) setRequest.mResult;
	}		}

	@UnsupportedAppUsage		@UnsupportedAppUsage
	@@ -1517,6 +1480,18 @@ public class IccSmsInterfaceManager {
	return result != null ? result : destAddr;		return result != null ? result : destAddr;
	}		}

			private void waitForResult(Request request) {
			synchronized (request) {
			while (!request.mStatus.get()) {
			try {
			request.wait();
			} catch (InterruptedException e) {
			log("Interrupted while waiting for result");
			}
			}
			}
			}

	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {		public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("Enabled GSM channels: " + mCellBroadcastRangeManager);		pw.println("Enabled GSM channels: " + mCellBroadcastRangeManager);
	pw.println("Enabled CDMA channels: " + mCdmaBroadcastRangeManager);		pw.println("Enabled CDMA channels: " + mCdmaBroadcastRangeManager);

tests/telephonytests/src/com/android/internal/telephony/ContextFixture.java

+5 −0

Original line number	Original line	Diff line number	Diff line
	@@ -535,6 +535,11 @@ public class ContextFixture implements TestFixture<Context> {
	enforceCallingOrSelfPermission(permission, message);		enforceCallingOrSelfPermission(permission, message);
	}		}

			@Override
			public void enforceCallingPermission(String permission, String message) {
			enforceCallingOrSelfPermission(permission, message);
			}

	@Override		@Override
	public int checkCallingOrSelfPermission(String permission) {		public int checkCallingOrSelfPermission(String permission) {
	if (mPermissionTable.contains(permission)		if (mPermissionTable.contains(permission)

tests/telephonytests/src/com/android/internal/telephony/IccSmsInterfaceManagerTest.java

0 → 100644

+145 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2020 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 static com.android.internal.telephony.TelephonyTestUtils.waitForMs;

			import android.os.AsyncResult;
			import android.os.Message;
			import android.testing.AndroidTestingRunner;
			import android.testing.TestableLooper;

			import androidx.test.filters.SmallTest;

			import static org.junit.Assert.assertEquals;
			import static org.junit.Assert.fail;
			import static org.mockito.ArgumentMatchers.any;
			import static org.mockito.ArgumentMatchers.anyString;
			import static org.mockito.Mockito.verify;
			import static org.mockito.Mockito.when;

			import org.junit.After;
			import org.junit.Before;
			import org.junit.Test;
			import org.junit.runner.RunWith;
			import org.mockito.ArgumentCaptor;
			import org.mockito.Mock;

			import java.util.concurrent.CountDownLatch;
			import java.util.concurrent.TimeUnit;

			@RunWith(AndroidTestingRunner.class)
			@TestableLooper.RunWithLooper
			public class IccSmsInterfaceManagerTest extends TelephonyTest {
			// object under test
			private IccSmsInterfaceManager mIccSmsInterfaceManager;

			@Mock
			private SmsPermissions mMockSmsPermissions;

			@Before
			public void setUp() throws Exception {
			super.setUp(getClass().getSimpleName());
			mIccSmsInterfaceManager = new IccSmsInterfaceManager(mPhone, mContext, mAppOpsManager,
			mSmsDispatchersController, mMockSmsPermissions);
			}

			@After
			public void tearDown() throws Exception {
			super.tearDown();
			}

			@Test
			@SmallTest
			public void testSynchronization() throws Exception {
			mContextFixture.addCallingOrSelfPermission(android.Manifest.permission
			.RECEIVE_EMERGENCY_BROADCAST);
			when(mMockSmsPermissions.checkCallingOrSelfCanGetSmscAddress(anyString(), anyString()))
			.thenReturn(true);
			mSimulatedCommands.mSendSetGsmBroadcastConfigResponse = false;
			mSimulatedCommands.mSendGetSmscAddressResponse = false;
			CountDownLatch enableRangeLatch = new CountDownLatch(1);
			CountDownLatch getSmscLatch = new CountDownLatch(1);

			// call enableGsmBroadcastRange from first thread
			Thread enableRangeThread = new Thread(new Runnable() {
			@Override
			public void run() {
			mIccSmsInterfaceManager.enableGsmBroadcastRange(0, 5);
			enableRangeLatch.countDown();
			}
			});
			enableRangeThread.start();

			// call getSmscAddressFromIccEf from second thread
			Thread getSmscThread = new Thread(new Runnable() {
			@Override
			public void run() {
			mIccSmsInterfaceManager.getSmscAddressFromIccEf("calling package");
			getSmscLatch.countDown();
			}
			});
			getSmscThread.start();

			// wait for half a second to let the threads send their messages
			waitForMs(500);
			processAllMessages();

			// latch count should not be reduced until response is sent
			assertEquals("enableRangeLatch.getCount should be 1", 1, enableRangeLatch.getCount());
			assertEquals("getSmscLatch.getCount should be 1", 1, getSmscLatch.getCount());

			// send back response for first request and assert that only the first thread is unblocked
			ArgumentCaptor<Message> enableRangeCaptor = ArgumentCaptor.forClass(Message.class);
			verify(mSimulatedCommandsVerifier).setGsmBroadcastConfig(any(),
			enableRangeCaptor.capture());
			Message enableRangeResponse = enableRangeCaptor.getValue();
			AsyncResult.forMessage(enableRangeResponse);
			enableRangeResponse.sendToTarget();
			processAllMessages();

			// the response triggers setGsmBroadcastActivation and since that's on another thread
			// (enableRangeThread), wait for half a second for the response message of that to reach
			// the handler before calling processAllMessages(). Consider increasing this timeout if the
			// test fails.
			waitForMs(500);
			processAllMessages();

			try {
			assertEquals("enableRangeLatch.await should be true", true,
			enableRangeLatch.await(5, TimeUnit.SECONDS));
			} catch (InterruptedException ie) {
			fail("enableRangeLatch.await interrupted");
			}
			assertEquals("getSmscLatch.getCount should still be 1", 1, getSmscLatch.getCount());

			// send back response for second request and assert that the second thread gets unblocked
			ArgumentCaptor<Message> getSmscCaptor = ArgumentCaptor.forClass(Message.class);
			verify(mSimulatedCommandsVerifier).getSmscAddress(getSmscCaptor.capture());
			Message getSmscResponse = getSmscCaptor.getValue();
			AsyncResult.forMessage(getSmscResponse);
			getSmscResponse.sendToTarget();
			processAllMessages();

			try {
			assertEquals("getSmscLatch.await should be true", true,
			getSmscLatch.await(5, TimeUnit.SECONDS));
			} catch (InterruptedException ie) {
			fail("getSmscLatch.await interrupted");
			}
			}
			}

tests/telephonytests/src/com/android/internal/telephony/SimulatedCommands.java

+10 −2

Original line number	Original line	Diff line number	Diff line
	@@ -149,6 +149,8 @@ public class SimulatedCommands extends BaseCommands
	public int mDefaultRoamingIndicator;		public int mDefaultRoamingIndicator;
	public int mReasonForDenial;		public int mReasonForDenial;
	public int mMaxDataCalls;		public int mMaxDataCalls;
			public boolean mSendSetGsmBroadcastConfigResponse = true;
			public boolean mSendGetSmscAddressResponse = true;

	private SignalStrength mSignalStrength;		private SignalStrength mSignalStrength;
	private List<CellInfo> mCellInfoList = null;		private List<CellInfo> mCellInfoList = null;
	@@ -1246,8 +1248,11 @@ public class SimulatedCommands extends BaseCommands

	@Override		@Override
	public void getSmscAddress(Message result) {		public void getSmscAddress(Message result) {
			SimulatedCommandsVerifier.getInstance().getSmscAddress(result);
			if (mSendGetSmscAddressResponse) {
	unimplemented(result);		unimplemented(result);
	}		}
			}

	@Override		@Override
	public void setSmscAddress(String address, Message result) {		public void setSmscAddress(String address, Message result) {
	@@ -1867,8 +1872,11 @@ public class SimulatedCommands extends BaseCommands

	@Override		@Override
	public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response) {		public void setGsmBroadcastConfig(SmsBroadcastConfigInfo[] config, Message response) {
			SimulatedCommandsVerifier.getInstance().setGsmBroadcastConfig(config, response);
			if (mSendSetGsmBroadcastConfigResponse) {
	unimplemented(response);		unimplemented(response);
	}		}
			}

	@Override		@Override
	public void getGsmBroadcastConfig(Message response) {		public void getGsmBroadcastConfig(Message response) {