Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 71f6a3c8 authored by Rika Brooks's avatar Rika Brooks Committed by Linux Build Service Account
Browse files

Telephony: Add enable/disable APIs for Cdma CMAS 

- Add enable/disable APIs for Cdma broadcast to SmsManager.
  Create CdmaBroadcastRangeManager extended from existing IntRangeManager.
- Add synchronized to enable/disable broadcast APIs for Cdma and Gsm.
- Fix decodeCallbackNumber to check for valid param size
- Don't ack CB messages

Change-Id: I390bc74d970f316fc29955662b528cb8c974ad41
parent da162c32

src/java/android/telephony/SmsManager.java

+123 −0
Original line number Diff line number Diff line
@@ -493,6 +493,129 @@ public final class SmsManager { 
        return success;

    }



    /**

     * Enable reception of cdma broadcast messages with the given message

     * identifier. Note that if two different clients enable the same message

     * identifier, they must both disable it for the device to stop receiving

     * those messages. All received messages will be broadcast in an intent with

     * the action "android.provider.telephony.SMS_CB_RECEIVED".

     * 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 C.R1001-G

     * @return true if successful, false otherwise

     * @see #disableCdmaBroadcast(int) {@hide}

     */

    public boolean enableCdmaBroadcast(int messageIdentifier) {

        boolean success = false;



        try {

            ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));

            if (iccISms != null) {

                success = iccISms.enableCdmaBroadcast(messageIdentifier);

            }

        } catch (RemoteException ex) {

            // ignore it

        }



        return success;

    }



    /**

     * Disable reception of cdma broadcast messages with the given message

     * identifier. Note that if two different clients enable the same message

     * identifier, they must both disable it for the device to stop receiving

     * those messages. 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 C.R1001-G

     * @return true if successful, false otherwise

     * @see #enableCdmaBroadcast(int) {@hide}

     */

    public boolean disableCdmaBroadcast(int messageIdentifier) {

        boolean success = false;



        try {

            ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));

            if (iccISms != null) {

                success = iccISms.disableCdmaBroadcast(messageIdentifier);

            }

        } catch (RemoteException ex) {

            // ignore it

        }



        return success;

    }



    /**

     * Enable reception of cdma broadcast messages within the given message

     * identifier range. Note that if two different clients enable the same

     * message identifier, they must both disable it for the device to stop

     * receiving those messages. All received messages will be broadcast in an

     * intent with the action

     * "android.provider.telephony.SMS_CB_RECEIVED". Note: This call

     * is blocking, callers may want to avoid calling it from the main thread of

     * an application.

     *

     * @param startMessageId Start Message identifier as specified in C.R1001-G

     * @param endMessageId End Message identifier as specified in C.R1001-G

     * @return true if successful, false otherwise

     * @see #disableCdmaBroadcastRange(int, int)

     *

     * @throws IllegalArgumentException if endMessageId < startMessageId

     * {@hide}

     */

    public boolean enableCdmaBroadcastRange(int startMessageId, int endMessageId) {

        boolean success = false;



        if (endMessageId < startMessageId) {

            throw new IllegalArgumentException("endMessageId < startMessageId");

        }

        try {

            ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));

            if (iccISms != null) {

                success = iccISms.enableCdmaBroadcastRange(startMessageId, endMessageId);

            }

        } catch (RemoteException ex) {

            // ignore it

        }



        return success;

    }



    /**

     * Disable reception of cdma broadcast messages within the given message

     * identifier range. Note that if two different clients enable the same

     * message identifier, they must both disable it for the device to stop

     * receiving those messages. Note: This call is blocking, callers may want

     * to avoid calling it from the main thread of an application.

     *

     * @param startMessageId Start Message identifier as specified in C.R1001-G

     * @param endMessageId End Message identifier as specified in C.R1001-G

     * @return true if successful, false otherwise

     * @see #enableCdmaBroadcastRange(int, int)

     *

     * @throws IllegalArgumentException if endMessageId < startMessageId

     * {@hide}

     */

    public boolean disableCdmaBroadcastRange(int startMessageId, int endMessageId) {

        boolean success = false;



        if (endMessageId < startMessageId) {

            throw new IllegalArgumentException("endMessageId < startMessageId");

        }

        try {

            ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));

            if (iccISms != null) {

                success = iccISms.disableCdmaBroadcastRange(startMessageId, endMessageId);

            }

        } catch (RemoteException ex) {

            // ignore it

        }



        return success;

    }



    /**

     * Create a list of <code>SmsMessage</code>s from a list of RawSmsData

     * records returned by <code>getAllMessagesFromIcc()</code>

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

+148 −2
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ import android.util.Log; 


import com.android.internal.telephony.ISms;

import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;

import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;

import com.android.internal.telephony.uicc.IccConstants;

import com.android.internal.telephony.uicc.IccFileHandler;

import com.android.internal.util.HexDump;
@@ -57,6 +58,8 @@ public class IccSmsInterfaceManager extends ISms.Stub { 


    private CellBroadcastRangeManager mCellBroadcastRangeManager =

            new CellBroadcastRangeManager();

    private CdmaBroadcastRangeManager mCdmaBroadcastRangeManager =

        new CdmaBroadcastRangeManager();



    private static final int EVENT_LOAD_DONE = 1;

    private static final int EVENT_UPDATE_DONE = 2;
@@ -546,7 +549,7 @@ public class IccSmsInterfaceManager extends ISms.Stub { 
        return disableCellBroadcastRange(messageIdentifier, messageIdentifier);

    }



    public boolean enableCellBroadcastRange(int startMessageId, int endMessageId) {

    synchronized public boolean enableCellBroadcastRange(int startMessageId, int endMessageId) {

        if (DBG) log("enableCellBroadcastRange");



        Context context = mPhone.getContext();
@@ -573,7 +576,7 @@ public class IccSmsInterfaceManager extends ISms.Stub { 
        return true;

    }



    public boolean disableCellBroadcastRange(int startMessageId, int endMessageId) {

    synchronized public boolean disableCellBroadcastRange(int startMessageId, int endMessageId) {

        if (DBG) log("disableCellBroadcastRange");



        Context context = mPhone.getContext();
@@ -600,6 +603,69 @@ public class IccSmsInterfaceManager extends ISms.Stub { 
        return true;

    }



    public boolean enableCdmaBroadcast(int messageIdentifier) {

        return enableCdmaBroadcastRange(messageIdentifier, messageIdentifier);

    }



    public boolean disableCdmaBroadcast(int messageIdentifier) {

        return disableCdmaBroadcastRange(messageIdentifier, messageIdentifier);

    }





    synchronized public boolean enableCdmaBroadcastRange(int startMessageId, int endMessageId) {

        if (DBG) log("enableCdmaBroadcastRange");



        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;

    }



    synchronized public boolean disableCdmaBroadcastRange(int startMessageId, int endMessageId) {

        if (DBG) log("disableCdmaBroadcastRange");



        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 CellBroadcastRangeManager extends IntRangeManager {

        private ArrayList<SmsBroadcastConfigInfo> mConfigList =

                new ArrayList<SmsBroadcastConfigInfo>();
@@ -640,6 +706,46 @@ public class IccSmsInterfaceManager extends ISms.Stub { 
        }

    }



    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 setCellBroadcastConfig(SmsBroadcastConfigInfo[] configs) {

        if (DBG)

            log("Calling setGsmBroadcastConfig with " + configs.length + " configurations");
@@ -680,6 +786,46 @@ public class IccSmsInterfaceManager extends ISms.Stub { 
        return mSuccess;

    }



    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.mCi.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.mCi.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) {

        Log.d(LOG_TAG, "[IccSmsInterfaceManager] " + msg);

    }