Telephony: Define enable/disable APIs for Cdma CMAS
Rika Brooks [Tue, 24 Jul 2012 01:36:14 +0000 (18:36 -0700)]
- Define enableCellBroadcastRange, disableCellBroadcastRange,
  enableCellBroadcast, disableCellBroadcast for Cdma broadcast.
  Create CdmaBroadcastRangeManager extended from existing IntRangeManager.

Change-Id: I5d70175862547475f49e08328ab3dcc5560e9096

src/java/android/telephony/SmsManager.java
src/java/com/android/internal/telephony/CommandsInterface.java
src/java/com/android/internal/telephony/ISms.aidl
src/java/com/android/internal/telephony/RIL.java
src/java/com/android/internal/telephony/cdma/CdmaSmsBroadcastConfigInfo.java [new file with mode: 0755]
src/java/com/android/internal/telephony/cdma/RuimSmsInterfaceManager.java
src/java/com/android/internal/telephony/sip/SipCommandInterface.java
src/java/com/android/internal/telephony/test/SimulatedCommands.java
tests/telephonytests/src/com/android/internal/telephony/gsm/UsimDataDownloadCommands.java

index da9d7e7..e782379 100644 (file)
@@ -358,7 +358,8 @@ public final class SmsManager {
      * Note: This call is blocking, callers may want to avoid calling it from
      * the main thread of an application.
      *
-     * @param messageIdentifier Message identifier as specified in TS 23.041
+     * @param messageIdentifier Message identifier as specified in TS 23.041 (3GPP)
+     * or C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      * @see #disableCellBroadcast(int)
      *
@@ -387,7 +388,8 @@ public final class SmsManager {
      * Note: This call is blocking, callers may want to avoid calling it from
      * the main thread of an application.
      *
-     * @param messageIdentifier Message identifier as specified in TS 23.041
+     * @param messageIdentifier Message identifier as specified in TS 23.041 (3GPP)
+     * or C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      *
      * @see #enableCellBroadcast(int)
@@ -418,8 +420,10 @@ public final class SmsManager {
      * Note: This call is blocking, callers may want to avoid calling it from
      * the main thread of an application.
      *
-     * @param startMessageId first message identifier as specified in TS 23.041
-     * @param endMessageId last message identifier as specified in TS 23.041
+     * @param startMessageId first message identifier as specified in TS 23.041 (3GPP)
+     * or C.R1001-G (3GPP2)
+     * @param endMessageId last message identifier as specified in TS 23.041 (3GPP)
+     * or C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      * @see #disableCellBroadcastRange(int, int)
      *
@@ -452,8 +456,10 @@ public final class SmsManager {
      * Note: This call is blocking, callers may want to avoid calling it from
      * the main thread of an application.
      *
-     * @param startMessageId first message identifier as specified in TS 23.041
-     * @param endMessageId last message identifier as specified in TS 23.041
+     * @param startMessageId first message identifier as specified in TS 23.041 (3GPP)
+     * or C.R1001-G (3GPP2)
+     * @param endMessageId last message identifier as specified in TS 23.041 (3GPP)
+     * or C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      *
      * @see #enableCellBroadcastRange(int, int)
index d9c3dc7..fc116ef 100644 (file)
@@ -16,6 +16,7 @@
 
 package com.android.internal.telephony;
 
+import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
 import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
 import com.android.internal.telephony.uicc.IccCardStatus;
 
@@ -1523,11 +1524,10 @@ public interface CommandsInterface {
     /**
      * Configure cdma cell broadcast SMS.
      *
-     * @param result
+     * @param response
      *            Callback message is empty on completion
      */
-    // TODO: Change the configValuesArray to a RIL_BroadcastSMSConfig
-    public void setCdmaBroadcastConfig(int[] configValuesArray, Message result);
+    public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response);
 
     /**
      * Query the current configuration of cdma cell broadcast SMS.
index 1fd9f70..6917b1b 100644 (file)
@@ -150,7 +150,8 @@ interface ISms {
      * message identifier, they must both disable it for the device to stop
      * receiving those messages.
      *
-     * @param messageIdentifier Message identifier as specified in TS 23.041
+     * @param messageIdentifier Message identifier as specified in TS 23.041 (3GPP) or
+     *   C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      *
      * @see #disableCellBroadcast(int)
@@ -163,21 +164,24 @@ interface ISms {
      * message identifier, they must both disable it for the device to stop
      * receiving those messages.
      *
-     * @param messageIdentifier Message identifier as specified in TS 23.041
+     * @param messageIdentifier Message identifier as specified in TS 23.041 (3GPP) or
+     *   C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      *
      * @see #enableCellBroadcast(int)
      */
     boolean disableCellBroadcast(int messageIdentifier);
 
-    /**
+    /*
      * Enable reception of cell broadcast (SMS-CB) messages with the given
      * message identifier range. Note that if two different clients enable
      * a message identifier range, they must both disable it for the device
      * to stop receiving those messages.
      *
-     * @param startMessageId first message identifier as specified in TS 23.041
-     * @param endMessageId last message identifier as specified in TS 23.041
+     * @param startMessageId first message identifier as specified in TS 23.041 (3GPP) or
+     *   C.R1001-G (3GPP2)
+     * @param endMessageId last message identifier as specified in TS 23.041 (3GPP) or
+     *   C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      *
      * @see #disableCellBroadcastRange(int, int)
@@ -190,8 +194,10 @@ interface ISms {
      * a message identifier range, they must both disable it for the device
      * to stop receiving those messages.
      *
-     * @param startMessageId first message identifier as specified in TS 23.041
-     * @param endMessageId last message identifier as specified in TS 23.041
+     * @param startMessageId first message identifier as specified in TS 23.041 (3GPP) or
+     *   C.R1001-G (3GPP2)
+     * @param endMessageId last message identifier as specified in TS 23.041 (3GPP) or
+     *   C.R1001-G (3GPP2)
      * @return true if successful, false otherwise
      *
      * @see #enableCellBroadcastRange(int, int)
index 29715ff..2dbd4d1 100644 (file)
@@ -58,6 +58,7 @@ import com.android.internal.telephony.uicc.IccRefreshResponse;
 import com.android.internal.telephony.uicc.IccUtils;
 import com.android.internal.telephony.cdma.CdmaCallWaitingNotification;
 import com.android.internal.telephony.cdma.CdmaInformationRecords;
+import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
 
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
@@ -3817,15 +3818,36 @@ public final class RIL extends BaseCommands implements CommandsInterface {
         send(rr);
     }
 
-    // TODO: Change the configValuesArray to a RIL_BroadcastSMSConfig
-    public void setCdmaBroadcastConfig(int[] configValuesArray, Message response) {
+    public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) {
         RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG, response);
 
-        for(int i = 0; i < configValuesArray.length; i++) {
-            rr.mp.writeInt(configValuesArray[i]);
+        // Convert to 1 service category per config (the way RIL takes is)
+        ArrayList<CdmaSmsBroadcastConfigInfo> processedConfigs =
+            new ArrayList<CdmaSmsBroadcastConfigInfo>();
+        for (CdmaSmsBroadcastConfigInfo config : configs) {
+            for (int i = config.getFromServiceCategory(); i <= config.getToServiceCategory(); i++) {
+                processedConfigs.add(new CdmaSmsBroadcastConfigInfo(i,
+                        i,
+                        config.getLanguage(),
+                        config.isSelected()));
+            }
         }
 
-        if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+        CdmaSmsBroadcastConfigInfo[] rilConfigs = processedConfigs.toArray(configs);
+        rr.mp.writeInt(rilConfigs.length);
+        for(int i = 0; i < rilConfigs.length; i++) {
+            rr.mp.writeInt(rilConfigs[i].getFromServiceCategory());
+            rr.mp.writeInt(rilConfigs[i].getLanguage());
+            rr.mp.writeInt(rilConfigs[i].isSelected() ? 1 : 0);
+        }
+
+        if (RILJ_LOGD) {
+            riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+                    + " with " + rilConfigs.length + " configs : ");
+            for (int i = 0; i < rilConfigs.length; i++) {
+                riljLog(rilConfigs[i].toString());
+            }
+        }
 
         send(rr);
     }
diff --git a/src/java/com/android/internal/telephony/cdma/CdmaSmsBroadcastConfigInfo.java b/src/java/com/android/internal/telephony/cdma/CdmaSmsBroadcastConfigInfo.java
new file mode 100755 (executable)
index 0000000..b31df59
--- /dev/null
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2011-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.cdma;
+
+/**
+ * CdmaSmsBroadcastConfigInfo defines one configuration of Cdma Broadcast
+ * Message to be received by the ME
+ *
+ * serviceCategory defines a Broadcast message identifier
+ * whose value is 0x0000 - 0xFFFF as defined in C.R1001G 9.3.1 and 9.3.2.
+ * All other values can be treated as empty message ID.
+ *
+ * language defines a language code of Broadcast Message
+ * whose value is 0x00 - 0x07 as defined in C.R1001G 9.2.
+ * All other values can be treated as empty language code.
+ *
+ * selected false means message types specified in serviceCategory
+ * are not accepted, while true means accepted.
+ *
+ */
+public class CdmaSmsBroadcastConfigInfo {
+    private int mFromServiceCategory;
+    private int mToServiceCategory;
+    private int mLanguage;
+    private boolean mSelected;
+
+    /**
+     * Initialize the object from rssi and cid.
+     */
+    public CdmaSmsBroadcastConfigInfo(int fromServiceCategory, int toServiceCategory,
+            int language, boolean selected) {
+        mFromServiceCategory = fromServiceCategory;
+        mToServiceCategory = toServiceCategory;
+        mLanguage = language;
+        mSelected = selected;
+    }
+
+    /**
+     * @return the mFromServiceCategory
+     */
+    public int getFromServiceCategory() {
+        return mFromServiceCategory;
+    }
+
+    /**
+     * @return the mToServiceCategory
+     */
+    public int getToServiceCategory() {
+        return mToServiceCategory;
+    }
+
+    /**
+     * @return the mLanguage
+     */
+    public int getLanguage() {
+        return mLanguage;
+    }
+
+    /**
+     * @return the selected
+     */
+    public boolean isSelected() {
+        return mSelected;
+    }
+
+    @Override
+    public String toString() {
+        return "CdmaSmsBroadcastConfigInfo: Id [" +
+            mFromServiceCategory + ", " + mToServiceCategory + "] " +
+            (isSelected() ? "ENABLED" : "DISABLED");
+    }
+}
index ff7d2ef..0679470 100644 (file)
 package com.android.internal.telephony.cdma;
 
 import android.content.Context;
+import android.os.Binder;
 import android.os.Message;
 import android.telephony.Rlog;
 
 import com.android.internal.telephony.IccSmsInterfaceManager;
+import com.android.internal.telephony.IntRangeManager;
 import com.android.internal.telephony.SMSDispatcher;
 import com.android.internal.telephony.uicc.IccUtils;
 
+import java.util.ArrayList;
+
 /**
  * RuimSmsInterfaceManager to provide an inter-process communication to
  * access Sms in Ruim.
@@ -33,6 +37,9 @@ public class RuimSmsInterfaceManager extends IccSmsInterfaceManager {
     static final String LOG_TAG = "CDMA";
     static final boolean DBG = true;
 
+    private CdmaBroadcastRangeManager mCdmaBroadcastRangeManager =
+        new CdmaBroadcastRangeManager();
+
     public RuimSmsInterfaceManager(CDMAPhone phone, SMSDispatcher dispatcher) {
         super(phone);
         mDispatcher = dispatcher;
@@ -61,27 +68,145 @@ public class RuimSmsInterfaceManager extends IccSmsInterfaceManager {
     }
 
     public boolean enableCellBroadcast(int messageIdentifier) {
-        // Not implemented
-        Rlog.e(LOG_TAG, "Error! Not implemented for CDMA.");
-        return false;
+        return enableCellBroadcastRange(messageIdentifier, messageIdentifier);
     }
 
     public boolean disableCellBroadcast(int messageIdentifier) {
-        // Not implemented
-        Rlog.e(LOG_TAG, "Error! Not implemented for CDMA.");
-        return false;
+        return disableCellBroadcastRange(messageIdentifier, messageIdentifier);
     }
 
     public boolean enableCellBroadcastRange(int startMessageId, int endMessageId) {
-        // Not implemented
-        Rlog.e(LOG_TAG, "Error! Not implemented for CDMA.");
-        return false;
+        if (DBG) log("enableCellBroadcastRange");
+
+        Context context = mPhone.getContext();
+
+        context.enforceCallingPermission(
+                "android.permission.RECEIVE_SMS",
+                "Enabling cdma broadcast SMS");
+
+        String client = context.getPackageManager().getNameForUid(
+                Binder.getCallingUid());
+
+        if (!mCdmaBroadcastRangeManager.enableRange(startMessageId, endMessageId, client)) {
+            log("Failed to add cdma broadcast subscription for MID range " + startMessageId
+                    + " to " + endMessageId + " from client " + client);
+            return false;
+        }
+
+        if (DBG)
+            log("Added cdma broadcast subscription for MID range " + startMessageId
+                    + " to " + endMessageId + " from client " + client);
+
+        setCdmaBroadcastActivation(!mCdmaBroadcastRangeManager.isEmpty());
+
+        return true;
     }
 
     public boolean disableCellBroadcastRange(int startMessageId, int endMessageId) {
-        // Not implemented
-        Rlog.e(LOG_TAG, "Error! Not implemented for CDMA.");
-        return false;
+        if (DBG) log("disableCellBroadcastRange");
+
+        Context context = mPhone.getContext();
+
+        context.enforceCallingPermission(
+                "android.permission.RECEIVE_SMS",
+                "Disabling cell broadcast SMS");
+
+        String client = context.getPackageManager().getNameForUid(
+                Binder.getCallingUid());
+
+        if (!mCdmaBroadcastRangeManager.disableRange(startMessageId, endMessageId, client)) {
+            log("Failed to remove cdma broadcast subscription for MID range " + startMessageId
+                    + " to " + endMessageId + " from client " + client);
+            return false;
+        }
+
+        if (DBG)
+            log("Removed cdma broadcast subscription for MID range " + startMessageId
+                    + " to " + endMessageId + " from client " + client);
+
+        setCdmaBroadcastActivation(!mCdmaBroadcastRangeManager.isEmpty());
+
+        return true;
+    }
+
+    class CdmaBroadcastRangeManager extends IntRangeManager {
+        private ArrayList<CdmaSmsBroadcastConfigInfo> mConfigList =
+                new ArrayList<CdmaSmsBroadcastConfigInfo>();
+
+        /**
+         * Called when the list of enabled ranges has changed. This will be
+         * followed by zero or more calls to {@link #addRange} followed by
+         * a call to {@link #finishUpdate}.
+         */
+        protected void startUpdate() {
+            mConfigList.clear();
+        }
+
+        /**
+         * Called after {@link #startUpdate} to indicate a range of enabled
+         * values.
+         * @param startId the first id included in the range
+         * @param endId the last id included in the range
+         */
+        protected void addRange(int startId, int endId, boolean selected) {
+            mConfigList.add(new CdmaSmsBroadcastConfigInfo(startId, endId,
+                        1, selected));
+        }
+
+        /**
+         * Called to indicate the end of a range update started by the
+         * previous call to {@link #startUpdate}.
+         * @return true if successful, false otherwise
+         */
+        protected boolean finishUpdate() {
+            if (mConfigList.isEmpty()) {
+                return true;
+            } else {
+                CdmaSmsBroadcastConfigInfo[] configs =
+                        mConfigList.toArray(new CdmaSmsBroadcastConfigInfo[mConfigList.size()]);
+                return setCdmaBroadcastConfig(configs);
+            }
+        }
+    }
+
+    private boolean setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs) {
+        if (DBG)
+            log("Calling setCdmaBroadcastConfig with " + configs.length + " configurations");
+
+        synchronized (mLock) {
+            Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_CONFIG_DONE);
+
+            mSuccess = false;
+            mPhone.mCM.setCdmaBroadcastConfig(configs, response);
+
+            try {
+                mLock.wait();
+            } catch (InterruptedException e) {
+                log("interrupted while trying to set cdma broadcast config");
+            }
+        }
+
+        return mSuccess;
+    }
+
+    private boolean setCdmaBroadcastActivation(boolean activate) {
+        if (DBG)
+            log("Calling setCdmaBroadcastActivation(" + activate + ")");
+
+        synchronized (mLock) {
+            Message response = mHandler.obtainMessage(EVENT_SET_BROADCAST_ACTIVATION_DONE);
+
+            mSuccess = false;
+            mPhone.mCM.setCdmaBroadcastActivation(activate, response);
+
+            try {
+                mLock.wait();
+            } catch (InterruptedException e) {
+                log("interrupted while trying to set cdma broadcast activation");
+            }
+        }
+
+        return mSuccess;
     }
 
     protected void log(String msg) {
index 99f4e0f..33a61f5 100644 (file)
@@ -23,6 +23,7 @@ import android.os.Message;
 import com.android.internal.telephony.BaseCommands;
 import com.android.internal.telephony.CommandsInterface;
 import com.android.internal.telephony.UUSInfo;
+import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
 import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
 
 /**
@@ -382,7 +383,7 @@ class SipCommandInterface extends BaseCommands implements CommandsInterface {
     public void getCdmaBroadcastConfig(Message response) {
     }
 
-    public void setCdmaBroadcastConfig(int[] configValuesArray, Message response) {
+    public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) {
     }
 
     public void setCdmaBroadcastActivation(boolean activate, Message response) {
index 1672044..5125a40 100644 (file)
@@ -28,6 +28,7 @@ import com.android.internal.telephony.CommandsInterface;
 import com.android.internal.telephony.DataCallState;
 import com.android.internal.telephony.Phone;
 import com.android.internal.telephony.UUSInfo;
+import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
 import com.android.internal.telephony.gsm.CallFailCause;
 import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
 import com.android.internal.telephony.gsm.SuppServiceNotification;
@@ -1461,9 +1462,8 @@ public final class SimulatedCommands extends BaseCommands
 
     }
 
-    public void setCdmaBroadcastConfig(int[] configValuesArray, Message response) {
+    public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) {
         unimplemented(response);
-
     }
 
     public void forceDataDormancy(Message response) {
index f001977..980be13 100644 (file)
@@ -25,6 +25,7 @@ import android.telephony.Rlog;
 import com.android.internal.telephony.BaseCommands;
 import com.android.internal.telephony.UUSInfo;
 import com.android.internal.telephony.uicc.IccIoResult;
+import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
 
 import junit.framework.Assert;
 
@@ -590,7 +591,7 @@ class UsimDataDownloadCommands extends BaseCommands {
     }
 
     @Override
-    public void setCdmaBroadcastConfig(int[] configValuesArray, Message result) {
+    public void setCdmaBroadcastConfig(CdmaSmsBroadcastConfigInfo[] configs, Message response) {
     }
 
     @Override