frameworks/base/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.Context;
  25 import android.content.Intent;
  26 import android.location.LocationManager;
  27 import android.os.Bundle;
  28 import android.os.RemoteException;
  29 import android.util.Log;
  30
  31 /**
  32  * A GPS Network-initiated Handler class used by LocationManager.
  33  *
  34  * {@hide}
  35  */
  36 public class GpsNetInitiatedHandler {
  37
  38     private static final String TAG = "GpsNetInitiatedHandler";
  39
  40     private static final boolean DEBUG = true;
  41     private static final boolean VERBOSE = false;
  42
  43     // NI verify activity for bringing up UI (not used yet)
  44     public static final String ACTION_NI_VERIFY = "android.intent.action.NETWORK_INITIATED_VERIFY";
  45
  46     // string constants for defining data fields in NI Intent
  47     public static final String NI_INTENT_KEY_NOTIF_ID = "notif_id";
  48     public static final String NI_INTENT_KEY_TITLE = "title";
  49     public static final String NI_INTENT_KEY_MESSAGE = "message";
  50     public static final String NI_INTENT_KEY_TIMEOUT = "timeout";
  51     public static final String NI_INTENT_KEY_DEFAULT_RESPONSE = "default_resp";
  52
  53     // the extra command to send NI response to GpsLocationProvider
  54     public static final String NI_RESPONSE_EXTRA_CMD = "send_ni_response";
  55
  56     // the extra command parameter names in the Bundle
  57     public static final String NI_EXTRA_CMD_NOTIF_ID = "notif_id";
  58     public static final String NI_EXTRA_CMD_RESPONSE = "response";
  59
  60     // these need to match GpsNiType constants in gps_ni.h
  61     public static final int GPS_NI_TYPE_VOICE = 1;
  62     public static final int GPS_NI_TYPE_UMTS_SUPL = 2;
  63     public static final int GPS_NI_TYPE_UMTS_CTRL_PLANE = 3;
  64
  65     // these need to match GpsUserResponseType constants in gps_ni.h
  66     public static final int GPS_NI_RESPONSE_ACCEPT = 1;
  67     public static final int GPS_NI_RESPONSE_DENY = 2;
  68     public static final int GPS_NI_RESPONSE_NORESP = 3;
  69
  70     // these need to match GpsNiNotifyFlags constants in gps_ni.h
  71     public static final int GPS_NI_NEED_NOTIFY = 0x0001;
  72     public static final int GPS_NI_NEED_VERIFY = 0x0002;
  73     public static final int GPS_NI_PRIVACY_OVERRIDE = 0x0004;
  74
  75     // these need to match GpsNiEncodingType in gps_ni.h
  76     public static final int GPS_ENC_NONE = 0;
  77     public static final int GPS_ENC_SUPL_GSM_DEFAULT = 1;
  78     public static final int GPS_ENC_SUPL_UTF8 = 2;
  79     public static final int GPS_ENC_SUPL_UCS2 = 3;
  80     public static final int GPS_ENC_UNKNOWN = -1;
  81
  82     private final Context mContext;
  83
  84     // parent gps location provider
  85     private final LocationManager mLocationManager;
  86
  87     // configuration of notificaiton behavior
  88     private boolean mPlaySounds = false;
  89     private boolean visible = true;
  90     private boolean mPopupImmediately = true;
  91
  92     // Set to true if string from HAL is encoded as Hex, e.g., "3F0039"
  93     static private boolean mIsHexInput = true;
  94
  95     public static class GpsNiNotification
  96     {
  97         public int notificationId;
  98         public int niType;
  99         public boolean needNotify;
 100         public boolean needVerify;
 101         public boolean privacyOverride;
 102         public int timeout;
 103         public int defaultResponse;
 104         public String requestorId;
 105         public String text;
 106         public int requestorIdEncoding;
 107         public int textEncoding;
 108         public Bundle extras;
 109     };
 110
 111     public static class GpsNiResponse {
 112         /* User reponse, one of the values in GpsUserResponseType */
 113         int userResponse;
 114         /* Optional extra data to pass with the user response */
 115         Bundle extras;
 116     };
 117
 118     /**
 119      * The notification that is shown when a network-initiated notification
 120      * (and verification) event is received.
 121      * <p>
 122      * This is lazily created, so use {@link #setNINotification()}.
 123      */
 124     private Notification mNiNotification;
 125
 126     public GpsNetInitiatedHandler(Context context) {
 127         mContext = context;
 128         mLocationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
 129     }
 130
 131     // Handles NI events from HAL
 132     public void handleNiNotification(GpsNiNotification notif)
 133     {
 134         if (DEBUG) Log.d(TAG, "handleNiNotification" + " notificationId: " + notif.notificationId
 135                 + " requestorId: " + notif.requestorId + " text: " + notif.text);
 136
 137         // Notify and verify with immediate pop-up
 138         if (notif.needNotify && notif.needVerify && mPopupImmediately)
 139         {
 140             // Popup the dialog box now
 141             openNiDialog(notif);
 142         }
 143
 144         // Notify only, or delayed pop-up (change mPopupImmediately to FALSE)
 145         if (notif.needNotify && !notif.needVerify ||
 146             notif.needNotify && notif.needVerify && !mPopupImmediately)
 147         {
 148             // Show the notification
 149
 150             // if mPopupImmediately == FALSE and needVerify == TRUE, a dialog will be opened
 151             // when the user opens the notification message
 152
 153             setNiNotification(notif);
 154         }
 155
 156         // ACCEPT cases: 1. Notify, no verify; 2. no notify, no verify; 3. privacy override.
 157         if ( notif.needNotify && !notif.needVerify ||
 158             !notif.needNotify && !notif.needVerify ||
 159              notif.privacyOverride)
 160         {
 161             mLocationManager.sendNiResponse(notif.notificationId, GPS_NI_RESPONSE_ACCEPT);
 162         }
 163
 164         //////////////////////////////////////////////////////////////////////////
 165         //   A note about timeout
 166         //   According to the protocol, in the need_notify and need_verify case,
 167         //   a default response should be sent when time out.
 168         //
 169         //   In some GPS hardware, the GPS driver (under HAL) can handle the timeout case
 170         //   and this class GpsNetInitiatedHandler does not need to do anything.
 171         //
 172         //   However, the UI should at least close the dialog when timeout. Further,
 173         //   for more general handling, timeout response should be added to the Handler here.
 174         //
 175     }
 176
 177     // Sets the NI notification.
 178     private synchronized void setNiNotification(GpsNiNotification notif) {
 179         NotificationManager notificationManager = (NotificationManager) mContext
 180                 .getSystemService(Context.NOTIFICATION_SERVICE);
 181         if (notificationManager == null) {
 182             return;
 183         }
 184
 185         String title = getNotifTitle(notif);
 186         String message = getNotifMessage(notif);
 187
 188         if (DEBUG) Log.d(TAG, "setNiNotification, notifyId: " + notif.notificationId +
 189                 ", title: " + title +
 190                 ", message: " + message);
 191
 192         // Construct Notification
 193         if (mNiNotification == null) {
 194             mNiNotification = new Notification();
 195             mNiNotification.icon = com.android.internal.R.drawable.stat_sys_gps_on; /* Change notification icon here */
 196             mNiNotification.when = 0;
 197         }
 198
 199         if (mPlaySounds) {
 200             mNiNotification.defaults |= Notification.DEFAULT_SOUND;
 201         } else {
 202             mNiNotification.defaults &= ~Notification.DEFAULT_SOUND;
 203         }
 204
 205         mNiNotification.flags = Notification.FLAG_ONGOING_EVENT;
 206         mNiNotification.tickerText = getNotifTicker(notif);
 207
 208         // if not to popup dialog immediately, pending intent will open the dialog
 209         Intent intent = !mPopupImmediately ? getDlgIntent(notif) : new Intent();
 210         PendingIntent pi = PendingIntent.getBroadcast(mContext, 0, intent, 0);
 211         mNiNotification.setLatestEventInfo(mContext, title, message, pi);
 212
 213         if (visible) {
 214             notificationManager.notify(notif.notificationId, mNiNotification);
 215         } else {
 216             notificationManager.cancel(notif.notificationId);
 217         }
 218     }
 219
 220     // Opens the notification dialog and waits for user input
 221     private void openNiDialog(GpsNiNotification notif)
 222     {
 223         Intent intent = getDlgIntent(notif);
 224
 225         if (DEBUG) Log.d(TAG, "openNiDialog, notifyId: " + notif.notificationId +
 226                 ", requestorId: " + notif.requestorId +
 227                 ", text: " + notif.text);
 228
 229         mContext.startActivity(intent);
 230     }
 231
 232     // Construct the intent for bringing up the dialog activity, which shows the
 233     // notification and takes user input
 234     private Intent getDlgIntent(GpsNiNotification notif)
 235     {
 236         Intent intent = new Intent();
 237         String title = getDialogTitle(notif);
 238         String message = getDialogMessage(notif);
 239
 240         // directly bring up the NI activity
 241         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 242         intent.setClass(mContext, com.android.internal.app.NetInitiatedActivity.class);
 243
 244         // put data in the intent
 245         intent.putExtra(NI_INTENT_KEY_NOTIF_ID, notif.notificationId);
 246         intent.putExtra(NI_INTENT_KEY_TITLE, title);
 247         intent.putExtra(NI_INTENT_KEY_MESSAGE, message);
 248         intent.putExtra(NI_INTENT_KEY_TIMEOUT, notif.timeout);
 249         intent.putExtra(NI_INTENT_KEY_DEFAULT_RESPONSE, notif.defaultResponse);
 250
 251         if (DEBUG) Log.d(TAG, "generateIntent, title: " + title + ", message: " + message +
 252                 ", timeout: " + notif.timeout);
 253
 254         return intent;
 255     }
 256
 257     // Converts a string (or Hex string) to a char array
 258     static byte[] stringToByteArray(String original, boolean isHex)
 259     {
 260         int length = isHex ? original.length() / 2 : original.length();
 261         byte[] output = new byte[length];
 262         int i;
 263
 264         if (isHex)
 265         {
 266             for (i = 0; i < length; i++)
 267             {
 268                 output[i] = (byte) Integer.parseInt(original.substring(i*2, i*2+2), 16);
 269             }
 270         }
 271         else {
 272             for (i = 0; i < length; i++)
 273             {
 274                 output[i] = (byte) original.charAt(i);
 275             }
 276         }
 277
 278         return output;
 279     }
 280
 281     /**
 282      * Unpacks an byte array containing 7-bit packed characters into a String.
 283      *
 284      * @param input a 7-bit packed char array
 285      * @return the unpacked String
 286      */
 287     static String decodeGSMPackedString(byte[] input)
 288     {
 289         final char CHAR_CR = 0x0D;
 290         int nStridx = 0;
 291         int nPckidx = 0;
 292         int num_bytes = input.length;
 293         int cPrev = 0;
 294         int cCurr = 0;
 295         byte nShift;
 296         byte nextChar;
 297         byte[] stringBuf = new byte[input.length * 2];
 298         String result = "";
 299
 300         while(nPckidx < num_bytes)
 301         {
 302             nShift = (byte) (nStridx & 0x07);
 303             cCurr = input[nPckidx++];
 304             if (cCurr < 0) cCurr += 256;
 305
 306             /* A 7-bit character can be split at the most between two bytes of packed
 307              ** data.
 308              */
 309             nextChar = (byte) (( (cCurr << nShift) | (cPrev >> (8-nShift)) ) & 0x7F);
 310             stringBuf[nStridx++] = nextChar;
 311
 312             /* Special case where the whole of the next 7-bit character fits inside
 313              ** the current byte of packed data.
 314              */
 315             if(nShift == 6)
 316             {
 317                 /* If the next 7-bit character is a CR (0x0D) and it is the last
 318                  ** character, then it indicates a padding character. Drop it.
 319                  */
 320                 if (nPckidx == num_bytes || (cCurr >> 1) == CHAR_CR)
 321                 {
 322                     break;
 323                 }
 324
 325                 nextChar = (byte) (cCurr >> 1);
 326                 stringBuf[nStridx++] = nextChar;
 327             }
 328
 329             cPrev = cCurr;
 330         }
 331
 332         try {
 333             result = new String(stringBuf, 0, nStridx, "US-ASCII");
 334         }
 335         catch (UnsupportedEncodingException e)
 336         {
 337             Log.e(TAG, e.getMessage());
 338         }
 339
 340         return result;
 341     }
 342
 343     static String decodeUTF8String(byte[] input)
 344     {
 345         String decoded = "";
 346         try {
 347             decoded = new String(input, "UTF-8");
 348         }
 349         catch (UnsupportedEncodingException e)
 350         {
 351             Log.e(TAG, e.getMessage());
 352         }
 353         return decoded;
 354     }
 355
 356     static String decodeUCS2String(byte[] input)
 357     {
 358         String decoded = "";
 359         try {
 360             decoded = new String(input, "UTF-16");
 361         }
 362         catch (UnsupportedEncodingException e)
 363         {
 364             Log.e(TAG, e.getMessage());
 365         }
 366         return decoded;
 367     }
 368
 369     /** Decode NI string
 370      *
 371      * @param original   The text string to be decoded
 372      * @param isHex      Specifies whether the content of the string has been encoded as a Hex string. Encoding
 373      *                   a string as Hex can allow zeros inside the coded text.
 374      * @param coding     Specifies the coding scheme of the string, such as GSM, UTF8, UCS2, etc. This coding scheme
 375      *                      needs to match those used passed to HAL from the native GPS driver. Decoding is done according
 376      *                   to the <code> coding </code>, after a Hex string is decoded. Generally, if the
 377      *                   notification strings don't need further decoding, <code> coding </code> encoding can be
 378      *                   set to -1, and <code> isHex </code> can be false.
 379      * @return the decoded string
 380      */
 381     static private String decodeString(String original, boolean isHex, int coding)
 382     {
 383         String decoded = original;
 384         byte[] input = stringToByteArray(original, isHex);
 385
 386         switch (coding) {
 387         case GPS_ENC_NONE:
 388             decoded = original;
 389             break;
 390
 391         case GPS_ENC_SUPL_GSM_DEFAULT:
 392             decoded = decodeGSMPackedString(input);
 393             break;
 394
 395         case GPS_ENC_SUPL_UTF8:
 396             decoded = decodeUTF8String(input);
 397             break;
 398
 399         case GPS_ENC_SUPL_UCS2:
 400             decoded = decodeUCS2String(input);
 401             break;
 402
 403         case GPS_ENC_UNKNOWN:
 404             decoded = original;
 405             break;
 406
 407         default:
 408             Log.e(TAG, "Unknown encoding " + coding + " for NI text " + original);
 409             break;
 410         }
 411         return decoded;
 412     }
 413
 414     // change this to configure notification display
 415     static private String getNotifTicker(GpsNiNotification notif)
 416     {
 417         String ticker = String.format("Position request! ReqId: [%s] ClientName: [%s]",
 418                 decodeString(notif.requestorId, mIsHexInput, notif.requestorIdEncoding),
 419                 decodeString(notif.text, mIsHexInput, notif.textEncoding));
 420         return ticker;
 421     }
 422
 423     // change this to configure notification display
 424     static private String getNotifTitle(GpsNiNotification notif)
 425     {
 426         String title = String.format("Position Request");
 427         return title;
 428     }
 429
 430     // change this to configure notification display
 431     static private String getNotifMessage(GpsNiNotification notif)
 432     {
 433         String message = String.format(
 434                 "NI Request received from [%s] for client [%s]!",
 435                 decodeString(notif.requestorId, mIsHexInput, notif.requestorIdEncoding),
 436                 decodeString(notif.text, mIsHexInput, notif.textEncoding));
 437         return message;
 438     }
 439
 440     // change this to configure dialog display (for verification)
 441     static public String getDialogTitle(GpsNiNotification notif)
 442     {
 443         return getNotifTitle(notif);
 444     }
 445
 446     // change this to configure dialog display (for verification)
 447     static private String getDialogMessage(GpsNiNotification notif)
 448     {
 449         return getNotifMessage(notif);
 450     }
 451
 452 }