| /* |
| * Copyright (C) 2006 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.phone; |
| |
| import android.app.Notification; |
| import android.app.NotificationManager; |
| import android.app.PendingIntent; |
| import android.app.StatusBarManager; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.SharedPreferences; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ResolveInfo; |
| import android.content.pm.UserInfo; |
| import android.net.Uri; |
| import android.os.SystemProperties; |
| import android.os.UserHandle; |
| import android.os.UserManager; |
| import android.preference.PreferenceManager; |
| import android.provider.ContactsContract.PhoneLookup; |
| import android.provider.Settings; |
| import android.telecom.PhoneAccount; |
| import android.telephony.PhoneNumberUtils; |
| import android.telephony.ServiceState; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.widget.Toast; |
| |
| import com.android.internal.telephony.Phone; |
| import com.android.internal.telephony.PhoneConstants; |
| import com.android.internal.telephony.PhoneFactory; |
| import com.android.internal.telephony.PhoneBase; |
| import com.android.internal.telephony.TelephonyCapabilities; |
| |
| import java.util.List; |
| |
| /** |
| * NotificationManager-related utility code for the Phone app. |
| * |
| * This is a singleton object which acts as the interface to the |
| * framework's NotificationManager, and is used to display status bar |
| * icons and control other status bar-related behavior. |
| * |
| * @see PhoneGlobals.notificationMgr |
| */ |
| public class NotificationMgr { |
| private static final String LOG_TAG = "NotificationMgr"; |
| private static final boolean DBG = |
| (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1); |
| // Do not check in with VDBG = true, since that may write PII to the system log. |
| private static final boolean VDBG = false; |
| |
| private static final String ACTION_NETWORK_OPERATOR_SETTINGS_ASYNC = |
| "org.codeaurora.settings.NETWORK_OPERATOR_SETTINGS_ASYNC"; |
| // notification types |
| static final int MMI_NOTIFICATION = 1; |
| static final int NETWORK_SELECTION_NOTIFICATION = 2; |
| static final int VOICEMAIL_NOTIFICATION = 3; |
| static final int CALL_FORWARD_NOTIFICATION = 4; |
| static final int DATA_DISCONNECTED_ROAMING_NOTIFICATION = 5; |
| static final int SELECTED_OPERATOR_FAIL_NOTIFICATION = 6; |
| |
| static final int NOTIFICATION_ID_OFFSET = 50; |
| |
| /** The singleton NotificationMgr instance. */ |
| private static NotificationMgr sInstance; |
| |
| private PhoneGlobals mApp; |
| |
| private Context mContext; |
| private NotificationManager mNotificationManager; |
| private StatusBarManager mStatusBarManager; |
| private UserManager mUserManager; |
| private Toast mToast; |
| |
| public StatusBarHelper statusBarHelper; |
| |
| // used to track the notification of selected network unavailable |
| private boolean mSelectedUnavailableNotify = false; |
| |
| // Retry params for the getVoiceMailNumber() call; see updateMwi(). |
| private static final int MAX_VM_NUMBER_RETRIES = 5; |
| private static final int VM_NUMBER_RETRY_DELAY_MILLIS = 10000; |
| private int mVmNumberRetriesRemaining = MAX_VM_NUMBER_RETRIES; |
| |
| /** |
| * Private constructor (this is a singleton). |
| * @see #init(PhoneGlobals) |
| */ |
| private NotificationMgr(PhoneGlobals app) { |
| mApp = app; |
| mContext = app; |
| mNotificationManager = |
| (NotificationManager) app.getSystemService(Context.NOTIFICATION_SERVICE); |
| mStatusBarManager = |
| (StatusBarManager) app.getSystemService(Context.STATUS_BAR_SERVICE); |
| mUserManager = (UserManager) app.getSystemService(Context.USER_SERVICE); |
| statusBarHelper = new StatusBarHelper(); |
| } |
| |
| /** |
| * Initialize the singleton NotificationMgr instance. |
| * |
| * This is only done once, at startup, from PhoneApp.onCreate(). |
| * From then on, the NotificationMgr instance is available via the |
| * PhoneApp's public "notificationMgr" field, which is why there's no |
| * getInstance() method here. |
| */ |
| /* package */ static NotificationMgr init(PhoneGlobals app) { |
| synchronized (NotificationMgr.class) { |
| if (sInstance == null) { |
| sInstance = new NotificationMgr(app); |
| } else { |
| Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance); |
| } |
| return sInstance; |
| } |
| } |
| |
| /** |
| * Helper class that's a wrapper around the framework's |
| * StatusBarManager.disable() API. |
| * |
| * This class is used to control features like: |
| * |
| * - Disabling the status bar "notification windowshade" |
| * while the in-call UI is up |
| * |
| * - Disabling notification alerts (audible or vibrating) |
| * while a phone call is active |
| * |
| * - Disabling navigation via the system bar (the "soft buttons" at |
| * the bottom of the screen on devices with no hard buttons) |
| * |
| * We control these features through a single point of control to make |
| * sure that the various StatusBarManager.disable() calls don't |
| * interfere with each other. |
| */ |
| public class StatusBarHelper { |
| // Current desired state of status bar / system bar behavior |
| private boolean mIsNotificationEnabled = true; |
| private boolean mIsExpandedViewEnabled = true; |
| private boolean mIsSystemBarNavigationEnabled = true; |
| |
| private StatusBarHelper () { |
| } |
| |
| /** |
| * Enables or disables auditory / vibrational alerts. |
| * |
| * (We disable these any time a voice call is active, regardless |
| * of whether or not the in-call UI is visible.) |
| */ |
| public void enableNotificationAlerts(boolean enable) { |
| if (mIsNotificationEnabled != enable) { |
| mIsNotificationEnabled = enable; |
| updateStatusBar(); |
| } |
| } |
| |
| /** |
| * Enables or disables the expanded view of the status bar |
| * (i.e. the ability to pull down the "notification windowshade"). |
| * |
| * (This feature is disabled by the InCallScreen while the in-call |
| * UI is active.) |
| */ |
| public void enableExpandedView(boolean enable) { |
| if (mIsExpandedViewEnabled != enable) { |
| mIsExpandedViewEnabled = enable; |
| updateStatusBar(); |
| } |
| } |
| |
| /** |
| * Enables or disables the navigation via the system bar (the |
| * "soft buttons" at the bottom of the screen) |
| * |
| * (This feature is disabled while an incoming call is ringing, |
| * because it's easy to accidentally touch the system bar while |
| * pulling the phone out of your pocket.) |
| */ |
| public void enableSystemBarNavigation(boolean enable) { |
| if (mIsSystemBarNavigationEnabled != enable) { |
| mIsSystemBarNavigationEnabled = enable; |
| updateStatusBar(); |
| } |
| } |
| |
| /** |
| * Updates the status bar to reflect the current desired state. |
| */ |
| private void updateStatusBar() { |
| int state = StatusBarManager.DISABLE_NONE; |
| |
| if (!mIsExpandedViewEnabled) { |
| state |= StatusBarManager.DISABLE_EXPAND; |
| } |
| if (!mIsNotificationEnabled) { |
| state |= StatusBarManager.DISABLE_NOTIFICATION_ALERTS; |
| } |
| if (!mIsSystemBarNavigationEnabled) { |
| // Disable *all* possible navigation via the system bar. |
| state |= StatusBarManager.DISABLE_HOME; |
| state |= StatusBarManager.DISABLE_RECENT; |
| state |= StatusBarManager.DISABLE_BACK; |
| state |= StatusBarManager.DISABLE_SEARCH; |
| } |
| |
| if (DBG) log("updateStatusBar: state = 0x" + Integer.toHexString(state)); |
| mStatusBarManager.disable(state); |
| } |
| } |
| |
| /** The projection to use when querying the phones table */ |
| static final String[] PHONES_PROJECTION = new String[] { |
| PhoneLookup.NUMBER, |
| PhoneLookup.DISPLAY_NAME, |
| PhoneLookup._ID |
| }; |
| |
| /** |
| * Updates the message waiting indicator (voicemail) notification. |
| * |
| * @param visible true if there are messages waiting |
| */ |
| /* package */ void updateMwi(boolean visible, Phone phone) { |
| int phoneId = phone.getPhoneId(); |
| if (DBG) log("updateMwi(): " + visible + " phoneId = " + phoneId); |
| int [] mwiIcon = {R.drawable.stat_notify_voicemail_sub1, |
| R.drawable.stat_notify_voicemail_sub2, |
| R.drawable.stat_notify_voicemail_sub3}; |
| |
| int notificationId = getNotificationId(VOICEMAIL_NOTIFICATION, phoneId); |
| if (visible) { |
| int resId = android.R.drawable.stat_notify_voicemail; |
| if (PhoneUtils.isMultiSimEnabled()) { |
| resId = mwiIcon[phoneId]; |
| } |
| |
| // This Notification can get a lot fancier once we have more |
| // information about the current voicemail messages. |
| // (For example, the current voicemail system can't tell |
| // us the caller-id or timestamp of a message, or tell us the |
| // message count.) |
| |
| // But for now, the UI is ultra-simple: if the MWI indication |
| // is supposed to be visible, just show a single generic |
| // notification. |
| |
| String notificationTitle = mContext.getString(R.string.notification_voicemail_title); |
| String vmNumber = phone.getVoiceMailNumber(); |
| if (DBG) log("- got vm number: '" + vmNumber + "'"); |
| |
| // Watch out: vmNumber may be null, for two possible reasons: |
| // |
| // (1) This phone really has no voicemail number |
| // |
| // (2) This phone *does* have a voicemail number, but |
| // the SIM isn't ready yet. |
| // |
| // Case (2) *does* happen in practice if you have voicemail |
| // messages when the device first boots: we get an MWI |
| // notification as soon as we register on the network, but the |
| // SIM hasn't finished loading yet. |
| // |
| // So handle case (2) by retrying the lookup after a short |
| // delay. |
| |
| if ((vmNumber == null) && !phone.getIccRecordsLoaded()) { |
| if (DBG) log("- Null vm number: SIM records not loaded (yet)..."); |
| |
| // TODO: rather than retrying after an arbitrary delay, it |
| // would be cleaner to instead just wait for a |
| // SIM_RECORDS_LOADED notification. |
| // (Unfortunately right now there's no convenient way to |
| // get that notification in phone app code. We'd first |
| // want to add a call like registerForSimRecordsLoaded() |
| // to Phone.java and GSMPhone.java, and *then* we could |
| // listen for that in the CallNotifier class.) |
| |
| // Limit the number of retries (in case the SIM is broken |
| // or missing and can *never* load successfully.) |
| if (mVmNumberRetriesRemaining-- > 0) { |
| if (DBG) log(" - Retrying in " + VM_NUMBER_RETRY_DELAY_MILLIS + " msec..."); |
| mApp.notifier.sendMwiChangedDelayed(VM_NUMBER_RETRY_DELAY_MILLIS, phone); |
| return; |
| } else { |
| Log.w(LOG_TAG, "NotificationMgr.updateMwi: getVoiceMailNumber() failed after " |
| + MAX_VM_NUMBER_RETRIES + " retries; giving up."); |
| // ...and continue with vmNumber==null, just as if the |
| // phone had no VM number set up in the first place. |
| } |
| } |
| |
| if (TelephonyCapabilities.supportsVoiceMessageCount(phone)) { |
| int vmCount = phone.getVoiceMessageCount(); |
| String titleFormat = mContext.getString(R.string.notification_voicemail_title_count); |
| notificationTitle = String.format(titleFormat, vmCount); |
| } |
| |
| String notificationText; |
| if (TextUtils.isEmpty(vmNumber)) { |
| notificationText = mContext.getString( |
| R.string.notification_voicemail_no_vm_number); |
| } else { |
| notificationText = String.format( |
| mContext.getString(R.string.notification_voicemail_text_format), |
| PhoneNumberUtils.formatNumber(vmNumber)); |
| } |
| |
| Intent intent = new Intent(Intent.ACTION_CALL, |
| Uri.fromParts(PhoneAccount.SCHEME_VOICEMAIL, "", null)); |
| PendingIntent pendingIntent = PendingIntent.getActivity(mContext, 0, intent, 0); |
| |
| SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext); |
| Uri ringtoneUri; |
| String uriString = prefs.getString( |
| CallFeaturesSetting.BUTTON_VOICEMAIL_NOTIFICATION_RINGTONE_KEY, null); |
| if (!TextUtils.isEmpty(uriString)) { |
| ringtoneUri = Uri.parse(uriString); |
| } else { |
| ringtoneUri = Settings.System.DEFAULT_NOTIFICATION_URI; |
| } |
| |
| Notification.Builder builder = new Notification.Builder(mContext); |
| builder.setSmallIcon(resId) |
| .setWhen(System.currentTimeMillis()) |
| .setContentTitle(notificationTitle) |
| .setContentText(notificationText) |
| .setContentIntent(pendingIntent) |
| .setSound(ringtoneUri) |
| .setColor(mContext.getResources().getColor(R.color.dialer_theme_color)) |
| .setOngoing(true); |
| |
| CallFeaturesSetting.migrateVoicemailVibrationSettingsIfNeeded(prefs, phoneId); |
| final boolean vibrate = prefs.getBoolean( |
| CallFeaturesSetting.BUTTON_VOICEMAIL_NOTIFICATION_VIBRATE_KEY, false); |
| if (vibrate) { |
| builder.setDefaults(Notification.DEFAULT_VIBRATE); |
| } |
| |
| final Notification notification = builder.build(); |
| List<UserInfo> users = mUserManager.getUsers(true); |
| for (int i = 0; i < users.size(); i++) { |
| final UserInfo user = users.get(i); |
| final UserHandle userHandle = user.getUserHandle(); |
| if (!mUserManager.hasUserRestriction( |
| UserManager.DISALLOW_OUTGOING_CALLS, userHandle) |
| && !user.isManagedProfile()) { |
| mNotificationManager.notifyAsUser( |
| null /* tag */, notificationId, notification, userHandle); |
| } |
| } |
| } else { |
| mNotificationManager.cancelAsUser( |
| null /* tag */, notificationId, UserHandle.ALL); |
| } |
| } |
| |
| /** |
| * Updates the message call forwarding indicator notification. |
| * |
| * @param visible true if there are messages waiting |
| */ |
| /* package */ void updateCfi(boolean visible, Phone phone) { |
| int phoneId = phone.getPhoneId(); |
| if (DBG) log("updateCfi(): " + visible + " phoneId = " + phoneId); |
| int [] callfwdIcon = {R.drawable.stat_sys_phone_call_forward_sub1, |
| R.drawable.stat_sys_phone_call_forward_sub2, |
| R.drawable.stat_sys_phone_call_forward_sub3}; |
| |
| int notificationId = getNotificationId(CALL_FORWARD_NOTIFICATION, phoneId); |
| if (visible) { |
| // If Unconditional Call Forwarding (forward all calls) for VOICE |
| // is enabled, just show a notification. We'll default to expanded |
| // view for now, so the there is less confusion about the icon. If |
| // it is deemed too weird to have CF indications as expanded views, |
| // then we'll flip the flag back. |
| |
| // TODO: We may want to take a look to see if the notification can |
| // display the target to forward calls to. This will require some |
| // effort though, since there are multiple layers of messages that |
| // will need to propagate that information. |
| int resId = R.drawable.stat_sys_phone_call_forward; |
| if (PhoneUtils.isMultiSimEnabled()) { |
| resId = callfwdIcon[phoneId]; |
| } |
| |
| Notification.Builder builder = new Notification.Builder(mContext) |
| .setSmallIcon(resId) |
| .setContentTitle(mContext.getString(R.string.labelCF)) |
| .setContentText(mContext.getString(R.string.sum_cfu_enabled_indicator)) |
| .setShowWhen(false) |
| .setOngoing(true); |
| |
| Intent intent = new Intent(Intent.ACTION_MAIN); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| intent.setClassName("com.android.phone", "com.android.phone.CallFeaturesSetting"); |
| PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, 0); |
| |
| List<UserInfo> users = mUserManager.getUsers(true); |
| for (int i = 0; i < users.size(); i++) { |
| final UserInfo user = users.get(i); |
| if (user.isManagedProfile()) { |
| continue; |
| } |
| UserHandle userHandle = user.getUserHandle(); |
| builder.setContentIntent(userHandle.isOwner() ? contentIntent : null); |
| mNotificationManager.notifyAsUser( |
| null /* tag */, notificationId, builder.build(), userHandle); |
| } |
| } else { |
| mNotificationManager.cancelAsUser( |
| null /* tag */, notificationId, UserHandle.ALL); |
| } |
| } |
| |
| /** |
| * Shows the "data disconnected due to roaming" notification, which |
| * appears when you lose data connectivity because you're roaming and |
| * you have the "data roaming" feature turned off. |
| */ |
| /* package */ void showDataDisconnectedRoaming() { |
| if (DBG) log("showDataDisconnectedRoaming()..."); |
| |
| // "Mobile network settings" screen / dialog |
| Intent intent = new Intent(mContext, com.android.phone.SelectSubscription.class); |
| |
| intent.putExtra(SelectSubscription.PACKAGE, |
| "com.android.phone"); |
| intent.putExtra(SelectSubscription.TARGET_CLASS, |
| "com.android.phone.MSimMobileNetworkSubSettings"); |
| |
| PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, 0); |
| |
| final CharSequence contentText = mContext.getText(R.string.roaming_reenable_message); |
| |
| final Notification.Builder builder = new Notification.Builder(mContext) |
| .setSmallIcon(android.R.drawable.stat_sys_warning) |
| .setContentTitle(mContext.getText(R.string.roaming)) |
| .setColor(mContext.getResources().getColor(R.color.dialer_theme_color)) |
| .setContentText(contentText); |
| |
| List<UserInfo> users = mUserManager.getUsers(true); |
| for (int i = 0; i < users.size(); i++) { |
| final UserInfo user = users.get(i); |
| if (user.isManagedProfile()) { |
| continue; |
| } |
| UserHandle userHandle = user.getUserHandle(); |
| builder.setContentIntent(userHandle.isOwner() ? contentIntent : null); |
| final Notification notif = |
| new Notification.BigTextStyle(builder).bigText(contentText).build(); |
| mNotificationManager.notifyAsUser( |
| null /* tag */, DATA_DISCONNECTED_ROAMING_NOTIFICATION, notif, userHandle); |
| } |
| } |
| |
| /** |
| * Turns off the "data disconnected due to roaming" notification. |
| */ |
| /* package */ void hideDataDisconnectedRoaming() { |
| if (DBG) log("hideDataDisconnectedRoaming()..."); |
| mNotificationManager.cancel(DATA_DISCONNECTED_ROAMING_NOTIFICATION); |
| } |
| |
| /** |
| * Display the network selection "no service" notification |
| * @param operator is the numeric operator number |
| */ |
| private void showNetworkSelection(String operator, Phone phone) { |
| if (DBG) log("showNetworkSelection(" + operator + ")..."); |
| |
| int subId = phone.getSubId(); |
| Notification.Builder builder = new Notification.Builder(mContext) |
| .setSmallIcon(android.R.drawable.stat_sys_warning) |
| .setContentTitle(mContext.getString(R.string.notification_network_selection_title)) |
| .setContentText( |
| mContext.getString(R.string.notification_network_selection_text, operator)) |
| .setShowWhen(false) |
| .setOngoing(true); |
| |
| // create the target network operators settings intent |
| Intent intent; |
| if (isAppInstalled(ACTION_NETWORK_OPERATOR_SETTINGS_ASYNC)) { |
| intent = new Intent(ACTION_NETWORK_OPERATOR_SETTINGS_ASYNC); |
| } else { |
| intent = new Intent(Intent.ACTION_MAIN); |
| intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | |
| Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); |
| // Use NetworkSetting to handle the selection intent |
| intent.setComponent(new ComponentName("com.android.phone", |
| "com.android.phone.NetworkSetting")); |
| } |
| intent.putExtra(PhoneConstants.SUBSCRIPTION_KEY, subId); |
| PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, |
| PendingIntent.FLAG_UPDATE_CURRENT); |
| List<UserInfo> users = mUserManager.getUsers(true); |
| for (int i = 0; i < users.size(); i++) { |
| final UserInfo user = users.get(i); |
| if (user.isManagedProfile()) { |
| continue; |
| } |
| UserHandle userHandle = user.getUserHandle(); |
| builder.setContentIntent(userHandle.isOwner() ? contentIntent : null); |
| mNotificationManager.notifyAsUser( |
| null /* tag */, |
| SELECTED_OPERATOR_FAIL_NOTIFICATION, |
| builder.build(), |
| userHandle); |
| } |
| } |
| |
| private boolean isAppInstalled(String action) { |
| boolean installed = false; |
| PackageManager pm = mContext.getPackageManager(); |
| List<ResolveInfo> list = pm.queryIntentActivities(new Intent(action), 0); |
| int listSize = list.size(); |
| for (int i = 0; i < listSize; i++) { |
| ResolveInfo resolveInfo = list.get(i); |
| if ((resolveInfo.activityInfo.applicationInfo.flags |
| & ApplicationInfo.FLAG_SYSTEM) != 0) { |
| installed = true; |
| break; |
| } |
| } |
| return installed; |
| } |
| |
| /** |
| * Turn off the network selection "no service" notification |
| */ |
| private void cancelNetworkSelection() { |
| if (DBG) log("cancelNetworkSelection()..."); |
| mNotificationManager.cancelAsUser( |
| null /* tag */, SELECTED_OPERATOR_FAIL_NOTIFICATION, UserHandle.ALL); |
| } |
| |
| /** |
| * Update notification about no service of user selected operator |
| * |
| * @param serviceState Phone service state |
| */ |
| void updateNetworkSelection(int serviceState, Phone phone) { |
| if (TelephonyCapabilities.supportsNetworkSelection(phone)) { |
| // get the shared preference of network_selection. |
| // empty is auto mode, otherwise it is the operator alpha name |
| // in case there is no operator name, check the operator numeric |
| SharedPreferences sp = |
| PreferenceManager.getDefaultSharedPreferences(mContext); |
| String networkSelection = |
| sp.getString(PhoneBase.NETWORK_SELECTION_NAME_KEY, ""); |
| if (TextUtils.isEmpty(networkSelection)) { |
| networkSelection = |
| sp.getString(PhoneBase.NETWORK_SELECTION_KEY, ""); |
| } |
| |
| if (DBG) log("updateNetworkSelection()..." + "state = " + |
| serviceState + " new network " + networkSelection); |
| |
| if (serviceState == ServiceState.STATE_OUT_OF_SERVICE |
| && !TextUtils.isEmpty(networkSelection)) { |
| if (!mSelectedUnavailableNotify) { |
| showNetworkSelection(networkSelection, phone); |
| mSelectedUnavailableNotify = true; |
| } |
| } else { |
| if (mSelectedUnavailableNotify) { |
| cancelNetworkSelection(); |
| mSelectedUnavailableNotify = false; |
| } |
| } |
| } |
| } |
| |
| /* package */ void postTransientNotification(int notifyId, CharSequence msg) { |
| if (mToast != null) { |
| mToast.cancel(); |
| } |
| |
| mToast = Toast.makeText(mContext, msg, Toast.LENGTH_LONG); |
| mToast.show(); |
| } |
| |
| private int getNotificationId(int notificationId, int slotId) { |
| return notificationId + (slotId * NOTIFICATION_ID_OFFSET); |
| } |
| |
| private void log(String msg) { |
| Log.d(LOG_TAG, msg); |
| } |
| } |