Merge commit '3ab4c135be3d5d3bf529f63ef932f95526401feb' into HEAD (543d79cc) · Commits · e / devices / smdk4412 / android_frameworks_opt_telephony

src/java/android/provider/Telephony.java

+879 −392

File changed.

Preview size limit exceeded, changes collapsed.

src/java/android/telephony/SmsManager.java

+49 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 The Android Open Source Project
		* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		@@ -518,6 +519,54 @@ public final class SmsManager {
		return messages;
		}

		/**
		* SMS over IMS is supported if IMS is registered and SMS is supported
		* on IMS.
		*
		* @return true if SMS over IMS is supported, false otherwise
		*
		* @see #getImsSmsFormat()
		*
		* @hide
		*/
		boolean isImsSmsSupported() {
		boolean boSupported = false;
		try {
		ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
		if (iccISms != null) {
		boSupported = iccISms.isImsSmsSupported();
		}
		} catch (RemoteException ex) {
		// ignore it
		}
		return boSupported;
		}

		/**
		* Gets SMS format supported on IMS. SMS over IMS format is
		* either 3GPP or 3GPP2.
		*
		* @return SmsMessage.FORMAT_3GPP,
		* SmsMessage.FORMAT_3GPP2
		* or SmsMessage.FORMAT_UNKNOWN
		*
		* @see #isImsSmsSupported()
		*
		* @hide
		*/
		String getImsSmsFormat() {
		String format = com.android.internal.telephony.SmsConstants.FORMAT_UNKNOWN;
		try {
		ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
		if (iccISms != null) {
		format = iccISms.getImsSmsFormat();
		}
		} catch (RemoteException ex) {
		// ignore it
		}
		return format;
		}

		// see SmsMessage.getStatusOnIcc

		/** Free space (TS 51.011 10.5.3 / 3GPP2 C.S0023 3.4.27). */

src/java/android/telephony/SmsMessage.java

+51 −16

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 The Android Open Source Project
		* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		@@ -131,13 +132,26 @@ public class SmsMessage {
		* into the new method {@code createFromPdu(byte[], String)} which takes an
		* extra format parameter. This is required in order to correctly decode the PDU on
		* devices that require support for both 3GPP and 3GPP2 formats at the same time,
		* such as dual-mode GSM/CDMA and CDMA/LTE phones.
		* such as dual-mode GSM/CDMA and CDMA/LTE phones. Guess format based on Voice
		* technology first, if it fails use other format.
		*/
		public static SmsMessage createFromPdu(byte[] pdu) {
		SmsMessage message = null;

		// cdma(3gpp2) vs gsm(3gpp) format info was not given,
		// guess from active voice phone type
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();
		String format = (PHONE_TYPE_CDMA == activePhone) ?
		SmsConstants.FORMAT_3GPP2 : SmsConstants.FORMAT_3GPP;
		return createFromPdu(pdu, format);
		message = createFromPdu(pdu, format);

		if (null == message \|\| null == message.mWrappedSmsMessage) {
		// decoding pdu failed based on activePhone type, must be other format
		format = (PHONE_TYPE_CDMA == activePhone) ?
		SmsConstants.FORMAT_3GPP : SmsConstants.FORMAT_3GPP2;
		message = createFromPdu(pdu, format);
		}
		return message;
		}

		/**
		@@ -203,9 +217,8 @@ public class SmsMessage {
		*/
		public static SmsMessage createFromEfRecord(int index, byte[] data) {
		SmsMessageBase wrappedMessage;
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();

		if (PHONE_TYPE_CDMA == activePhone) {
		if (isCdmaVoice()) {
		wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.createFromEfRecord(
		index, data);
		} else {
		@@ -224,9 +237,7 @@ public class SmsMessage {
		* We should probably deprecate it and remove the obsolete test case.
		*/
		public static int getTPLayerLengthForPDU(String pdu) {
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();

		if (PHONE_TYPE_CDMA == activePhone) {
		if (isCdmaVoice()) {
		return com.android.internal.telephony.cdma.SmsMessage.getTPLayerLengthForPDU(pdu);
		} else {
		return com.android.internal.telephony.gsm.SmsMessage.getTPLayerLengthForPDU(pdu);
		@@ -259,8 +270,8 @@ public class SmsMessage {
		* code unit size (see the ENCODING_* definitions in SmsConstants)
		*/
		public static int[] calculateLength(CharSequence msgBody, boolean use7bitOnly) {
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();
		TextEncodingDetails ted = (PHONE_TYPE_CDMA == activePhone) ?
		// this function is for MO SMS
		TextEncodingDetails ted = (useCdmaFormatForMoSms()) ?
		com.android.internal.telephony.cdma.SmsMessage.calculateLength(msgBody, use7bitOnly) :
		com.android.internal.telephony.gsm.SmsMessage.calculateLength(msgBody, use7bitOnly);
		int ret[] = new int[4];
		@@ -282,8 +293,8 @@ public class SmsMessage {
		* @hide
		*/
		public static ArrayList<String> fragmentText(String text) {
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();
		TextEncodingDetails ted = (PHONE_TYPE_CDMA == activePhone) ?
		// This function is for MO SMS
		TextEncodingDetails ted = (useCdmaFormatForMoSms()) ?
		com.android.internal.telephony.cdma.SmsMessage.calculateLength(text, false) :
		com.android.internal.telephony.gsm.SmsMessage.calculateLength(text, false);

		@@ -325,7 +336,7 @@ public class SmsMessage {
		while (pos < textLen) {
		int nextPos = 0; // Counts code units.
		if (ted.codeUnitSize == SmsConstants.ENCODING_7BIT) {
		if (activePhone == PHONE_TYPE_CDMA && ted.msgCount == 1) {
		if (useCdmaFormatForMoSms() && ted.msgCount == 1) {
		// For a singleton CDMA message, the encoding must be ASCII...
		nextPos = pos + Math.min(limit, textLen - pos);
		} else {
		@@ -398,9 +409,8 @@ public class SmsMessage {
		public static SubmitPdu getSubmitPdu(String scAddress,
		String destinationAddress, String message, boolean statusReportRequested) {
		SubmitPduBase spb;
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();

		if (PHONE_TYPE_CDMA == activePhone) {
		if (useCdmaFormatForMoSms()) {
		spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress,
		destinationAddress, message, statusReportRequested, null);
		} else {
		@@ -428,9 +438,8 @@ public class SmsMessage {
		String destinationAddress, short destinationPort, byte[] data,
		boolean statusReportRequested) {
		SubmitPduBase spb;
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();

		if (PHONE_TYPE_CDMA == activePhone) {
		if (useCdmaFormatForMoSms()) {
		spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress,
		destinationAddress, destinationPort, data, statusReportRequested);
		} else {
		@@ -685,4 +694,30 @@ public class SmsMessage {
		public boolean isReplyPathPresent() {
		return mWrappedSmsMessage.isReplyPathPresent();
		}

		/**
		* Determines whether or not to use CDMA format for MO SMS.
		* If SMS over IMS is supported, then format is based on IMS SMS format,
		* otherwise format is based on current phone type.
		*
		* @return true if Cdma format should be used for MO SMS, false otherwise.
		*/
		private static boolean useCdmaFormatForMoSms() {
		if (!SmsManager.getDefault().isImsSmsSupported()) {
		// use Voice technology to determine SMS format.
		return isCdmaVoice();
		}
		// IMS is registered with SMS support, check the SMS format supported
		return (SmsConstants.FORMAT_3GPP2.equals(SmsManager.getDefault().getImsSmsFormat()));
		}

		/**
		* Determines whether or not to current phone type is cdma.
		*
		* @return true if current phone type is cdma, false otherwise.
		*/
		private static boolean isCdmaVoice() {
		int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();
		return (PHONE_TYPE_CDMA == activePhone);
		}
		}

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

+11 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2006 The Android Open Source Project
		* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		@@ -42,6 +43,7 @@ public abstract class BaseCommands implements CommandsInterface {
		protected RegistrantList mVoiceNetworkStateRegistrants = new RegistrantList();
		protected RegistrantList mDataNetworkStateRegistrants = new RegistrantList();
		protected RegistrantList mVoiceRadioTechChangedRegistrants = new RegistrantList();
		protected RegistrantList mImsNetworkStateChangedRegistrants = new RegistrantList();
		protected RegistrantList mIccStatusChangedRegistrants = new RegistrantList();
		protected RegistrantList mVoicePrivacyOnRegistrants = new RegistrantList();
		protected RegistrantList mVoicePrivacyOffRegistrants = new RegistrantList();
		@@ -121,6 +123,15 @@ public abstract class BaseCommands implements CommandsInterface {
		}
		}

		public void registerForImsNetworkStateChanged(Handler h, int what, Object obj) {
		Registrant r = new Registrant (h, what, obj);
		mImsNetworkStateChangedRegistrants.add(r);
		}

		public void unregisterForImsNetworkStateChanged(Handler h) {
		mImsNetworkStateChangedRegistrants.remove(h);
		}

		@Override
		public void registerForOn(Handler h, int what, Object obj) {
		Registrant r = new Registrant (h, what, obj);

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

0 → 100644

+96 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2013 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.Manifest;
		import android.app.Activity;
		import android.app.AppOpsManager;
		import android.content.Context;
		import android.content.Intent;
		import android.os.Message;
		import android.provider.Telephony;
		import android.telephony.SmsCbMessage;

		/**
		* Dispatch new Cell Broadcasts to receivers. Acquires a private wakelock until the broadcast
		* completes and our result receiver is called.
		*/
		public class CellBroadcastHandler extends WakeLockStateMachine {
		private final Context mContext;

		private CellBroadcastHandler(Context context) {
		this("CellBroadcastHandler", context);
		}

		protected CellBroadcastHandler(String debugTag, Context context) {
		super(debugTag, context);
		mContext = context;
		}

		/**
		* Create a new CellBroadcastHandler.
		* @param context the context to use for dispatching Intents
		* @return the new handler
		*/
		public static CellBroadcastHandler makeCellBroadcastHandler(Context context) {
		CellBroadcastHandler handler = new CellBroadcastHandler(context);
		handler.start();
		return handler;
		}

		/**
		* Handle Cell Broadcast messages from {@code CdmaInboundSmsHandler}.
		* 3GPP-format Cell Broadcast messages sent from radio are handled in the subclass.
		*
		* @param message the message to process
		* @return true if an ordered broadcast was sent; false on failure
		*/
		@Override
		protected boolean handleSmsMessage(Message message) {
		if (message.obj instanceof SmsCbMessage) {
		handleBroadcastSms((SmsCbMessage) message.obj);
		return true;
		} else {
		loge("handleMessage got object of type: " + message.obj.getClass().getName());
		return false;
		}
		}

		/**
		* Dispatch a Cell Broadcast message to listeners.
		* @param message the Cell Broadcast to broadcast
		*/
		protected void handleBroadcastSms(SmsCbMessage message) {
		String receiverPermission;
		int appOp;
		Intent intent;
		if (message.isEmergencyMessage()) {
		log("Dispatching emergency SMS CB");
		intent = new Intent(Telephony.Sms.Intents.SMS_EMERGENCY_CB_RECEIVED_ACTION);
		receiverPermission = Manifest.permission.RECEIVE_EMERGENCY_BROADCAST;
		appOp = AppOpsManager.OP_RECEIVE_EMERGECY_SMS;
		} else {
		log("Dispatching SMS CB");
		intent = new Intent(Telephony.Sms.Intents.SMS_CB_RECEIVED_ACTION);
		receiverPermission = Manifest.permission.RECEIVE_SMS;
		appOp = AppOpsManager.OP_RECEIVE_SMS;
		}
		intent.putExtra("message", message);
		mContext.sendOrderedBroadcast(intent, receiverPermission, appOp, mReceiver,
		getHandler(), Activity.RESULT_OK, null, null);
		}
		}