location/java/com/android/internal/location/GpsNetInitiatedHandler.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.internal.location;
  18
  19 import java.io.UnsupportedEncodingException;
  20
  21 import android.app.Notification;
  22 import android.app.NotificationManager;
  23 import android.app.PendingIntent;
  24 import android.content.BroadcastReceiver;
  25 import android.content.Context;
  26 import android.content.Intent;
  27 import android.content.IntentFilter;
  28 import android.location.LocationManager;
  29 import android.location.INetInitiatedListener;
  30 import android.telephony.TelephonyManager;
  31 import android.telephony.PhoneNumberUtils;
  32 import android.telephony.PhoneStateListener;
  33 import android.os.Bundle;
  34 import android.os.RemoteException;
  35 import android.os.UserHandle;
  36 import android.os.SystemProperties;
  37 import android.util.Log;
  38
  39 import com.android.internal.R;
  40 import com.android.internal.telephony.GsmAlphabet;
  41 import com.android.internal.telephony.TelephonyProperties;
  42
  43 /**
  44  * A GPS Network-initiated Handler class used by LocationManager.
  45  *
  46  * {@hide}
  47  */
  48 public class GpsNetInitiatedHandler {
  49
  50     private static final String TAG = "GpsNetInitiatedHandler";
  51
  52     private static final boolean DEBUG = true;
  53     private static final boolean VERBOSE = false;
  54
  55     // NI verify activity for bringing up UI (not used yet)
  56     public static final String ACTION_NI_VERIFY = "android.intent.action.NETWORK_INITIATED_VERIFY";
  57
  58     // string constants for defining data fields in NI Intent
  59     public static final String NI_INTENT_KEY_NOTIF_ID = "notif_id";
  60     public static final String NI_INTENT_KEY_TITLE = "title";
  61     public static final String NI_INTENT_KEY_MESSAGE = "message";
  62     public static final String NI_INTENT_KEY_TIMEOUT = "timeout";
  63     public static final String NI_INTENT_KEY_DEFAULT_RESPONSE = "default_resp";
  64
  65     // the extra command to send NI response to GnssLocationProvider
  66     public static final String NI_RESPONSE_EXTRA_CMD = "send_ni_response";
  67
  68     // the extra command parameter names in the Bundle
  69     public static final String NI_EXTRA_CMD_NOTIF_ID = "notif_id";
  70     public static final String NI_EXTRA_CMD_RESPONSE = "response";
  71
  72     // these need to match GpsNiType constants in gps_ni.h
  73     public static final int GPS_NI_TYPE_VOICE = 1;
  74     public static final int GPS_NI_TYPE_UMTS_SUPL = 2;
  75     public static final int GPS_NI_TYPE_UMTS_CTRL_PLANE = 3;
  76     public static final int GPS_NI_TYPE_EMERGENCY_SUPL = 4;
  77
  78     // these need to match GpsUserResponseType constants in gps_ni.h
  79     public static final int GPS_NI_RESPONSE_ACCEPT = 1;
  80     public static final int GPS_NI_RESPONSE_DENY = 2;
  81     public static final int GPS_NI_RESPONSE_NORESP = 3;
  82     public static final int GPS_NI_RESPONSE_IGNORE = 4;
  83
  84     // these need to match GpsNiNotifyFlags constants in gps_ni.h
  85     public static final int GPS_NI_NEED_NOTIFY = 0x0001;
  86     public static final int GPS_NI_NEED_VERIFY = 0x0002;
  87     public static final int GPS_NI_PRIVACY_OVERRIDE = 0x0004;
  88
  89     // these need to match GpsNiEncodingType in gps_ni.h
  90     public static final int GPS_ENC_NONE = 0;
  91     public static final int GPS_ENC_SUPL_GSM_DEFAULT = 1;
  92     public static final int GPS_ENC_SUPL_UTF8 = 2;
  93     public static final int GPS_ENC_SUPL_UCS2 = 3;
  94     public static final int GPS_ENC_UNKNOWN = -1;
  95
  96     private final Context mContext;
  97     private final TelephonyManager mTelephonyManager;
  98     private final PhoneStateListener mPhoneStateListener;
  99
 100     // parent gps location provider
 101     private final LocationManager mLocationManager;
 102
 103     // configuration of notificaiton behavior
 104     private boolean mPlaySounds = false;
 105     private boolean mPopupImmediately = true;
 106
 107     // read the SUPL_ES form gps.conf
 108     private volatile boolean mIsSuplEsEnabled;
 109
 110     // Set to true if the phone is having emergency call.
 111     private volatile boolean mIsInEmergency;
 112
 113     // If Location function is enabled.
 114     private volatile boolean mIsLocationEnabled = false;
 115
 116     private final INetInitiatedListener mNetInitiatedListener;
 117
 118     // Set to true if string from HAL is encoded as Hex, e.g., "3F0039"
 119     static private boolean mIsHexInput = true;
 120
 121     public static class GpsNiNotification
 122     {
 123         public int notificationId;
 124         public int niType;
 125         public boolean needNotify;
 126         public boolean needVerify;
 127         public boolean privacyOverride;
 128         public int timeout;
 129         public int defaultResponse;
 130         public String requestorId;
 131         public String text;
 132         public int requestorIdEncoding;
 133         public int textEncoding;
 134         public Bundle extras;
 135     };
 136
 137     public static class GpsNiResponse {
 138         /* User response, one of the values in GpsUserResponseType */
 139         int userResponse;
 140         /* Optional extra data to pass with the user response */
 141         Bundle extras;
 142     };
 143
 144     private final BroadcastReceiver mBroadcastReciever = new BroadcastReceiver() {
 145
 146         @Override public void onReceive(Context context, Intent intent) {
 147             String action = intent.getAction();
 148             if (action.equals(Intent.ACTION_NEW_OUTGOING_CALL)) {
 149                 String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
 150                 /*
 151                    Emergency Mode is when during emergency call or in emergency call back mode.
 152                    For checking if it is during emergency call:
 153                        mIsInEmergency records if the phone is in emergency call or not. It will
 154                        be set to true when the phone is having emergency call, and then will
 155                        be set to false by mPhoneStateListener when the emergency call ends.
 156                    For checking if it is in emergency call back mode:
 157                        Emergency call back mode will be checked by reading system properties
 158                        when necessary: SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE)
 159                 */
 160                 setInEmergency(PhoneNumberUtils.isEmergencyNumber(phoneNumber));
 161                 if (DEBUG) Log.v(TAG, "ACTION_NEW_OUTGOING_CALL - " + getInEmergency());
 162             } else if (action.equals(LocationManager.MODE_CHANGED_ACTION)) {
 163                 updateLocationMode();
 164                 if (DEBUG) Log.d(TAG, "location enabled :" + getLocationEnabled());
 165             }
 166         }
 167     };
 168
 169     /**
 170      * The notification that is shown when a network-initiated notification
 171      * (and verification) event is received.
 172      * <p>
 173      * This is lazily created, so use {@link #setNINotification()}.
 174      */
 175     private Notification.Builder mNiNotificationBuilder;
 176
 177     public GpsNetInitiatedHandler(Context context,
 178                                   INetInitiatedListener netInitiatedListener,
 179                                   boolean isSuplEsEnabled) {
 180         mContext = context;
 181
 182         if (netInitiatedListener == null) {
 183             throw new IllegalArgumentException("netInitiatedListener is null");
 184         } else {
 185             mNetInitiatedListener = netInitiatedListener;
 186         }
 187
 188         setSuplEsEnabled(isSuplEsEnabled);
 189         mLocationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
 190         updateLocationMode();
 191         mTelephonyManager =
 192             (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
 193
 194         mPhoneStateListener = new PhoneStateListener() {
 195             @Override
 196             public void onCallStateChanged(int state, String incomingNumber) {
 197                 if (DEBUG) Log.d(TAG, "onCallStateChanged(): state is "+ state);
 198                 // listening for emergency call ends
 199                 if (state == TelephonyManager.CALL_STATE_IDLE) {
 200                     setInEmergency(false);
 201                 }
 202             }
 203         };
 204         mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
 205
 206         IntentFilter intentFilter = new IntentFilter();
 207         intentFilter.addAction(Intent.ACTION_NEW_OUTGOING_CALL);
 208         intentFilter.addAction(LocationManager.MODE_CHANGED_ACTION);
 209         mContext.registerReceiver(mBroadcastReciever, intentFilter);
 210     }
 211
 212     public void setSuplEsEnabled(boolean isEnabled) {
 213         mIsSuplEsEnabled = isEnabled;
 214     }
 215
 216     public boolean getSuplEsEnabled() {
 217         return mIsSuplEsEnabled;
 218     }
 219
 220     /**
 221      * Updates Location enabler based on location setting.
 222      */
 223     public void updateLocationMode() {
 224         mIsLocationEnabled = mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
 225     }
 226
 227     /**
 228      * Checks if user agreed to use location.
 229      */
 230     public boolean getLocationEnabled() {
 231         return mIsLocationEnabled;
 232     }
 233
 234     // Note: Currently, there are two mechanisms involved to determine if a
 235     // phone is in emergency mode:
 236     // 1. If the user is making an emergency call, this is provided by activly
 237     //    monitoring the outgoing phone number;
 238     // 2. If the device is in a emergency callback state, this is provided by
 239     //    system properties.
 240     // If either one of above exists, the phone is considered in an emergency
 241     // mode. Because of this complexity, we need to be careful about how to set
 242     // and clear the emergency state.
 243     public void setInEmergency(boolean isInEmergency) {
 244         mIsInEmergency = isInEmergency;
 245     }
 246
 247     public boolean getInEmergency() {
 248         boolean isInEmergencyCallback = Boolean.parseBoolean(
 249                 SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE));
 250         return mIsInEmergency || isInEmergencyCallback;
 251     }
 252
 253
 254     // Handles NI events from HAL
 255     public void handleNiNotification(GpsNiNotification notif) {
 256         if (DEBUG) Log.d(TAG, "in handleNiNotification () :"
 257                         + " notificationId: " + notif.notificationId
 258                         + " requestorId: " + notif.requestorId
 259                         + " text: " + notif.text
 260                         + " mIsSuplEsEnabled" + getSuplEsEnabled()
 261                         + " mIsLocationEnabled" + getLocationEnabled());
 262
 263         if (getSuplEsEnabled()) {
 264             handleNiInEs(notif);
 265         } else {
 266             handleNi(notif);
 267         }
 268
 269         //////////////////////////////////////////////////////////////////////////
 270         //   A note about timeout
 271         //   According to the protocol, in the need_notify and need_verify case,
 272         //   a default response should be sent when time out.
 273         //
 274         //   In some GPS hardware, the GPS driver (under HAL) can handle the timeout case
 275         //   and this class GpsNetInitiatedHandler does not need to do anything.
 276         //
 277         //   However, the UI should at least close the dialog when timeout. Further,
 278         //   for more general handling, timeout response should be added to the Handler here.
 279         //
 280     }
 281
 282     // handle NI form HAL when SUPL_ES is disabled.
 283     private void handleNi(GpsNiNotification notif) {
 284         if (DEBUG) Log.d(TAG, "in handleNi () :"
 285                         + " needNotify: " + notif.needNotify
 286                         + " needVerify: " + notif.needVerify
 287                         + " privacyOverride: " + notif.privacyOverride
 288                         + " mPopupImmediately: " + mPopupImmediately
 289                         + " mInEmergency: " + getInEmergency());
 290
 291         if (!getLocationEnabled() && !getInEmergency()) {
 292             // Location is currently disabled, ignore all NI requests.
 293             try {
 294                 mNetInitiatedListener.sendNiResponse(notif.notificationId,
 295                                                      GPS_NI_RESPONSE_IGNORE);
 296             } catch (RemoteException e) {
 297                 Log.e(TAG, "RemoteException in sendNiResponse");
 298             }
 299         }
 300         if (notif.needNotify) {
 301         // If NI does not need verify or the dialog is not requested
 302         // to pop up immediately, the dialog box will not pop up.
 303             if (notif.needVerify && mPopupImmediately) {
 304                 // Popup the dialog box now
 305                 openNiDialog(notif);
 306             } else {
 307                 // Show the notification
 308                 setNiNotification(notif);
 309             }
 310         }
 311         // ACCEPT cases: 1. Notify, no verify; 2. no notify, no verify;
 312         // 3. privacy override.
 313         if (!notif.needVerify || notif.privacyOverride) {
 314             try {
 315                 mNetInitiatedListener.sendNiResponse(notif.notificationId,
 316                                                      GPS_NI_RESPONSE_ACCEPT);
 317             } catch (RemoteException e) {
 318                 Log.e(TAG, "RemoteException in sendNiResponse");
 319             }
 320         }
 321     }
 322
 323     // handle NI from HAL when the SUPL_ES is enabled
 324     private void handleNiInEs(GpsNiNotification notif) {
 325
 326         if (DEBUG) Log.d(TAG, "in handleNiInEs () :"
 327                     + " niType: " + notif.niType
 328                     + " notificationId: " + notif.notificationId);
 329
 330         // UE is in emergency mode when in emergency call mode or in emergency call back mode
 331         /*
 332            1. When SUPL ES bit is off and UE is not in emergency mode:
 333                   Call handleNi() to do legacy behaviour.
 334            2. When SUPL ES bit is on and UE is in emergency mode:
 335                   Call handleNi() to do acceptance behaviour.
 336            3. When SUPL ES bit is off but UE is in emergency mode:
 337                   Ignore the emergency SUPL INIT.
 338            4. When SUPL ES bit is on but UE is not in emergency mode:
 339                   Ignore the emergency SUPL INIT.
 340         */
 341         boolean isNiTypeES = (notif.niType == GPS_NI_TYPE_EMERGENCY_SUPL);
 342         if (isNiTypeES != getInEmergency()) {
 343             try {
 344                 mNetInitiatedListener.sendNiResponse(notif.notificationId,
 345                                                      GPS_NI_RESPONSE_IGNORE);
 346             } catch (RemoteException e) {
 347                 Log.e(TAG, "RemoteException in sendNiResponse");
 348             }
 349         } else {
 350             handleNi(notif);
 351         }
 352     }
 353
 354     // Sets the NI notification.
 355     private synchronized void setNiNotification(GpsNiNotification notif) {
 356         NotificationManager notificationManager = (NotificationManager) mContext
 357                 .getSystemService(Context.NOTIFICATION_SERVICE);
 358         if (notificationManager == null) {
 359             return;
 360         }
 361
 362         String title = getNotifTitle(notif, mContext);
 363         String message = getNotifMessage(notif, mContext);
 364
 365         if (DEBUG) Log.d(TAG, "setNiNotification, notifyId: " + notif.notificationId +
 366                 ", title: " + title +
 367                 ", message: " + message);
 368
 369         // Construct Notification
 370         if (mNiNotificationBuilder == null) {
 371             mNiNotificationBuilder = new Notification.Builder(mContext)
 372                     .setSmallIcon(com.android.internal.R.drawable.stat_sys_gps_on)
 373                     .setWhen(0)
 374                     .setOngoing(true)
 375                     .setAutoCancel(true)
 376                     .setColor(mContext.getColor(
 377                             com.android.internal.R.color.system_notification_accent_color));
 378         }
 379
 380         if (mPlaySounds) {
 381             mNiNotificationBuilder.setDefaults(Notification.DEFAULT_SOUND);
 382         } else {
 383             mNiNotificationBuilder.setDefaults(0);
 384         }
 385
 386         // if not to popup dialog immediately, pending intent will open the dialog
 387         Intent intent = !mPopupImmediately ? getDlgIntent(notif) : new Intent();
 388         PendingIntent pi = PendingIntent.getBroadcast(mContext, 0, intent, 0);
 389         mNiNotificationBuilder.setTicker(getNotifTicker(notif, mContext))
 390                 .setContentTitle(title)
 391                 .setContentText(message)
 392                 .setContentIntent(pi);
 393
 394         notificationManager.notifyAsUser(null, notif.notificationId, mNiNotificationBuilder.build(),
 395                 UserHandle.ALL);
 396     }
 397
 398     // Opens the notification dialog and waits for user input
 399     private void openNiDialog(GpsNiNotification notif)
 400     {
 401         Intent intent = getDlgIntent(notif);
 402
 403         if (DEBUG) Log.d(TAG, "openNiDialog, notifyId: " + notif.notificationId +
 404                 ", requestorId: " + notif.requestorId +
 405                 ", text: " + notif.text);
 406
 407         mContext.startActivity(intent);
 408     }
 409
 410     // Construct the intent for bringing up the dialog activity, which shows the
 411     // notification and takes user input
 412     private Intent getDlgIntent(GpsNiNotification notif)
 413     {
 414         Intent intent = new Intent();
 415         String title = getDialogTitle(notif, mContext);
 416         String message = getDialogMessage(notif, mContext);
 417
 418         // directly bring up the NI activity
 419         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
 420         intent.setClass(mContext, com.android.internal.app.NetInitiatedActivity.class);
 421
 422         // put data in the intent
 423         intent.putExtra(NI_INTENT_KEY_NOTIF_ID, notif.notificationId);
 424         intent.putExtra(NI_INTENT_KEY_TITLE, title);
 425         intent.putExtra(NI_INTENT_KEY_MESSAGE, message);
 426         intent.putExtra(NI_INTENT_KEY_TIMEOUT, notif.timeout);
 427         intent.putExtra(NI_INTENT_KEY_DEFAULT_RESPONSE, notif.defaultResponse);
 428
 429         if (DEBUG) Log.d(TAG, "generateIntent, title: " + title + ", message: " + message +
 430                 ", timeout: " + notif.timeout);
 431
 432         return intent;
 433     }
 434
 435     // Converts a string (or Hex string) to a char array
 436     static byte[] stringToByteArray(String original, boolean isHex)
 437     {
 438         int length = isHex ? original.length() / 2 : original.length();
 439         byte[] output = new byte[length];
 440         int i;
 441
 442         if (isHex)
 443         {
 444             for (i = 0; i < length; i++)
 445             {
 446                 output[i] = (byte) Integer.parseInt(original.substring(i*2, i*2+2), 16);
 447             }
 448         }
 449         else {
 450             for (i = 0; i < length; i++)
 451             {
 452                 output[i] = (byte) original.charAt(i);
 453             }
 454         }
 455
 456         return output;
 457     }
 458
 459     /**
 460      * Unpacks an byte array containing 7-bit packed characters into a String.
 461      *
 462      * @param input a 7-bit packed char array
 463      * @return the unpacked String
 464      */
 465     static String decodeGSMPackedString(byte[] input)
 466     {
 467         final char PADDING_CHAR = 0x00;
 468         int lengthBytes = input.length;
 469         int lengthSeptets = (lengthBytes * 8) / 7;
 470         String decoded;
 471
 472         /* Special case where the last 7 bits in the last byte could hold a valid
 473          * 7-bit character or a padding character. Drop the last 7-bit character
 474          * if it is a padding character.
 475          */
 476         if (lengthBytes % 7 == 0) {
 477             if (lengthBytes > 0) {
 478                 if ((input[lengthBytes - 1] >> 1) == PADDING_CHAR) {
 479                     lengthSeptets = lengthSeptets - 1;
 480                 }
 481             }
 482         }
 483
 484         decoded = GsmAlphabet.gsm7BitPackedToString(input, 0, lengthSeptets);
 485
 486         // Return "" if decoding of GSM packed string fails
 487         if (null == decoded) {
 488             Log.e(TAG, "Decoding of GSM packed string failed");
 489             decoded = "";
 490         }
 491
 492         return decoded;
 493     }
 494
 495     static String decodeUTF8String(byte[] input)
 496     {
 497         String decoded = "";
 498         try {
 499             decoded = new String(input, "UTF-8");
 500         }
 501         catch (UnsupportedEncodingException e)
 502         {
 503             throw new AssertionError();
 504         }
 505         return decoded;
 506     }
 507
 508     static String decodeUCS2String(byte[] input)
 509     {
 510         String decoded = "";
 511         try {
 512             decoded = new String(input, "UTF-16");
 513         }
 514         catch (UnsupportedEncodingException e)
 515         {
 516             throw new AssertionError();
 517         }
 518         return decoded;
 519     }
 520
 521     /** Decode NI string
 522      *
 523      * @param original   The text string to be decoded
 524      * @param isHex      Specifies whether the content of the string has been encoded as a Hex string. Encoding
 525      *                   a string as Hex can allow zeros inside the coded text.
 526      * @param coding     Specifies the coding scheme of the string, such as GSM, UTF8, UCS2, etc. This coding scheme
 527      *                      needs to match those used passed to HAL from the native GPS driver. Decoding is done according
 528      *                   to the <code> coding </code>, after a Hex string is decoded. Generally, if the
 529      *                   notification strings don't need further decoding, <code> coding </code> encoding can be
 530      *                   set to -1, and <code> isHex </code> can be false.
 531      * @return the decoded string
 532      */
 533     static private String decodeString(String original, boolean isHex, int coding)
 534     {
 535         String decoded = original;
 536         byte[] input = stringToByteArray(original, isHex);
 537
 538         switch (coding) {
 539         case GPS_ENC_NONE:
 540             decoded = original;
 541             break;
 542
 543         case GPS_ENC_SUPL_GSM_DEFAULT:
 544             decoded = decodeGSMPackedString(input);
 545             break;
 546
 547         case GPS_ENC_SUPL_UTF8:
 548             decoded = decodeUTF8String(input);
 549             break;
 550
 551         case GPS_ENC_SUPL_UCS2:
 552             decoded = decodeUCS2String(input);
 553             break;
 554
 555         case GPS_ENC_UNKNOWN:
 556             decoded = original;
 557             break;
 558
 559         default:
 560             Log.e(TAG, "Unknown encoding " + coding + " for NI text " + original);
 561             break;
 562         }
 563         return decoded;
 564     }
 565
 566     // change this to configure notification display
 567     static private String getNotifTicker(GpsNiNotification notif, Context context)
 568     {
 569         String ticker = String.format(context.getString(R.string.gpsNotifTicker),
 570                 decodeString(notif.requestorId, mIsHexInput, notif.requestorIdEncoding),
 571                 decodeString(notif.text, mIsHexInput, notif.textEncoding));
 572         return ticker;
 573     }
 574
 575     // change this to configure notification display
 576     static private String getNotifTitle(GpsNiNotification notif, Context context)
 577     {
 578         String title = String.format(context.getString(R.string.gpsNotifTitle));
 579         return title;
 580     }
 581
 582     // change this to configure notification display
 583     static private String getNotifMessage(GpsNiNotification notif, Context context)
 584     {
 585         String message = String.format(context.getString(R.string.gpsNotifMessage),
 586                 decodeString(notif.requestorId, mIsHexInput, notif.requestorIdEncoding),
 587                 decodeString(notif.text, mIsHexInput, notif.textEncoding));
 588         return message;
 589     }
 590
 591     // change this to configure dialog display (for verification)
 592     static public String getDialogTitle(GpsNiNotification notif, Context context)
 593     {
 594         return getNotifTitle(notif, context);
 595     }
 596
 597     // change this to configure dialog display (for verification)
 598     static private String getDialogMessage(GpsNiNotification notif, Context context)
 599     {
 600         return getNotifMessage(notif, context);
 601     }
 602
 603 }