| /* |
| * Copyright (C) 2011 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.ActivityManager; |
| import android.app.ActionBar; |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.SharedPreferences; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ResolveInfo; |
| import android.content.pm.ServiceInfo; |
| import android.content.res.Resources; |
| import android.graphics.drawable.Drawable; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.SystemProperties; |
| import android.preference.EditTextPreference; |
| import android.preference.Preference; |
| import android.preference.PreferenceActivity; |
| import android.telephony.PhoneNumberUtils; |
| import android.telephony.TelephonyManager; |
| import android.text.TextUtils; |
| import android.util.Log; |
| import android.view.LayoutInflater; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.AdapterView; |
| import android.widget.ArrayAdapter; |
| import android.widget.BaseAdapter; |
| import android.widget.CheckBox; |
| import android.widget.CompoundButton; |
| import android.widget.ImageView; |
| import android.widget.ListView; |
| import android.widget.TextView; |
| import android.widget.Toast; |
| |
| import com.android.internal.telephony.Call; |
| import com.android.internal.telephony.Connection; |
| import com.android.internal.telephony.PhoneConstants; |
| import com.google.android.collect.Lists; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| /** |
| * Helper class to manage the "Respond via Message" feature for incoming calls. |
| * |
| * @see InCallScreen.internalRespondViaSms() |
| */ |
| public class RespondViaSmsManager { |
| private static final String TAG = "RespondViaSmsManager"; |
| 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 PERMISSION_SEND_RESPOND_VIA_MESSAGE = |
| "android.permission.SEND_RESPOND_VIA_MESSAGE"; |
| |
| private int mIconSize = -1; |
| |
| /** |
| * Reference to the InCallScreen activity that owns us. This may be |
| * null if we haven't been initialized yet *or* after the InCallScreen |
| * activity has been destroyed. |
| */ |
| private InCallScreen mInCallScreen; |
| |
| /** |
| * The popup showing the list of canned responses. |
| * |
| * This is an AlertDialog containing a ListView showing the possible |
| * choices. This may be null if the InCallScreen hasn't ever called |
| * showRespondViaSmsPopup() yet, or if the popup was visible once but |
| * then got dismissed. |
| */ |
| private Dialog mCannedResponsePopup; |
| |
| /** |
| * The popup dialog allowing the user to chose which app handles respond-via-sms. |
| * |
| * An AlertDialog showing the Resolve-App UI resource from the framework wchih we then fill in |
| * with the appropriate data set. Can be null when not visible. |
| */ |
| private Dialog mPackageSelectionPopup; |
| |
| /** The array of "canned responses"; see loadCannedResponses(). */ |
| private String[] mCannedResponses; |
| |
| /** SharedPreferences file name for our persistent settings. */ |
| private static final String SHARED_PREFERENCES_NAME = "respond_via_sms_prefs"; |
| |
| // Preference keys for the 4 "canned responses"; see RespondViaSmsManager$Settings. |
| // Since (for now at least) the number of messages is fixed at 4, and since |
| // SharedPreferences can't deal with arrays anyway, just store the messages |
| // as 4 separate strings. |
| private static final int NUM_CANNED_RESPONSES = 4; |
| private static final String KEY_CANNED_RESPONSE_PREF_1 = "canned_response_pref_1"; |
| private static final String KEY_CANNED_RESPONSE_PREF_2 = "canned_response_pref_2"; |
| private static final String KEY_CANNED_RESPONSE_PREF_3 = "canned_response_pref_3"; |
| private static final String KEY_CANNED_RESPONSE_PREF_4 = "canned_response_pref_4"; |
| private static final String KEY_PREFERRED_PACKAGE = "preferred_package_pref"; |
| private static final String KEY_INSTANT_TEXT_DEFAULT_COMPONENT = "instant_text_def_component"; |
| |
| /** |
| * RespondViaSmsManager constructor. |
| */ |
| public RespondViaSmsManager() { |
| } |
| |
| public void setInCallScreenInstance(InCallScreen inCallScreen) { |
| mInCallScreen = inCallScreen; |
| |
| if (mInCallScreen != null) { |
| // Prefetch shared preferences to make the first canned response lookup faster |
| // (and to prevent StrictMode violation) |
| mInCallScreen.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE); |
| } |
| } |
| |
| /** |
| * Brings up the "Respond via SMS" popup for an incoming call. |
| * |
| * @param ringingCall the current incoming call |
| */ |
| public void showRespondViaSmsPopup(Call ringingCall) { |
| if (DBG) log("showRespondViaSmsPopup()..."); |
| |
| // Very quick succession of clicks can cause this to run twice. |
| // Stop here to avoid creating more than one popup. |
| if (isShowingPopup()) { |
| if (DBG) log("Skip showing popup when one is already shown."); |
| return; |
| } |
| |
| ListView lv = new ListView(mInCallScreen); |
| |
| // Refresh the array of "canned responses". |
| mCannedResponses = loadCannedResponses(); |
| |
| // Build the list: start with the canned responses, but manually add |
| // the write-your-own option as the last choice. |
| int numPopupItems = mCannedResponses.length + 1; |
| String[] popupItems = Arrays.copyOf(mCannedResponses, numPopupItems); |
| popupItems[numPopupItems - 1] = mInCallScreen.getResources() |
| .getString(R.string.respond_via_sms_custom_message); |
| |
| ArrayAdapter<String> adapter = |
| new ArrayAdapter<String>(mInCallScreen, |
| android.R.layout.simple_list_item_1, |
| android.R.id.text1, |
| popupItems); |
| lv.setAdapter(adapter); |
| |
| // Create a RespondViaSmsItemClickListener instance to handle item |
| // clicks from the popup. |
| // (Note we create a fresh instance for each incoming call, and |
| // stash away the call's phone number, since we can't necessarily |
| // assume this call will still be ringing when the user finally |
| // chooses a response.) |
| |
| Connection c = ringingCall.getLatestConnection(); |
| if (VDBG) log("- connection: " + c); |
| |
| if (c == null) { |
| // Uh oh -- the "ringingCall" doesn't have any connections any more. |
| // (In other words, it's no longer ringing.) This is rare, but can |
| // happen if the caller hangs up right at the exact moment the user |
| // selects the "Respond via SMS" option. |
| // There's nothing to do here (since the incoming call is gone), |
| // so just bail out. |
| Log.i(TAG, "showRespondViaSmsPopup: null connection; bailing out..."); |
| return; |
| } |
| |
| // TODO: at this point we probably should re-check c.getAddress() |
| // and c.getNumberPresentation() for validity. (i.e. recheck the |
| // same cases in InCallTouchUi.showIncomingCallWidget() where we |
| // should have disallowed the "respond via SMS" feature in the |
| // first place.) |
| |
| String phoneNumber = c.getAddress(); |
| if (VDBG) log("- phoneNumber: " + phoneNumber); |
| lv.setOnItemClickListener(new RespondViaSmsItemClickListener(phoneNumber)); |
| |
| AlertDialog.Builder builder = new AlertDialog.Builder(mInCallScreen) |
| .setCancelable(true) |
| .setOnCancelListener(new RespondViaSmsCancelListener()) |
| .setView(lv); |
| mCannedResponsePopup = builder.create(); |
| mCannedResponsePopup.show(); |
| } |
| |
| /** |
| * Dismiss currently visible popups. |
| * |
| * This is safe to call even if the popup is already dismissed, and |
| * even if you never called showRespondViaSmsPopup() in the first |
| * place. |
| */ |
| public void dismissPopup() { |
| if (mCannedResponsePopup != null) { |
| mCannedResponsePopup.dismiss(); // safe even if already dismissed |
| mCannedResponsePopup = null; |
| } |
| if (mPackageSelectionPopup != null) { |
| mPackageSelectionPopup.dismiss(); |
| mPackageSelectionPopup = null; |
| } |
| } |
| |
| public boolean isShowingPopup() { |
| return (mCannedResponsePopup != null && mCannedResponsePopup.isShowing()) |
| || (mPackageSelectionPopup != null && mPackageSelectionPopup.isShowing()); |
| } |
| |
| /** |
| * OnItemClickListener for the "Respond via SMS" popup. |
| */ |
| public class RespondViaSmsItemClickListener implements AdapterView.OnItemClickListener { |
| // Phone number to send the SMS to. |
| private String mPhoneNumber; |
| |
| public RespondViaSmsItemClickListener(String phoneNumber) { |
| mPhoneNumber = phoneNumber; |
| } |
| |
| /** |
| * Handles the user selecting an item from the popup. |
| */ |
| @Override |
| public void onItemClick(AdapterView<?> parent, // The ListView |
| View view, // The TextView that was clicked |
| int position, |
| long id) { |
| if (DBG) log("RespondViaSmsItemClickListener.onItemClick(" + position + ")..."); |
| String message = (String) parent.getItemAtPosition(position); |
| if (VDBG) log("- message: '" + message + "'"); |
| |
| // The "Custom" choice is a special case. |
| // (For now, it's guaranteed to be the last item.) |
| if (position == (parent.getCount() - 1)) { |
| // Take the user to the standard SMS compose UI. |
| launchSmsCompose(mPhoneNumber); |
| onPostMessageSent(); |
| } else { |
| sendTextToDefaultActivity(mPhoneNumber, message); |
| } |
| } |
| } |
| |
| |
| /** |
| * OnCancelListener for the "Respond via SMS" popup. |
| */ |
| public class RespondViaSmsCancelListener implements DialogInterface.OnCancelListener { |
| public RespondViaSmsCancelListener() { |
| } |
| |
| /** |
| * Handles the user canceling the popup, either by touching |
| * outside the popup or by pressing Back. |
| */ |
| @Override |
| public void onCancel(DialogInterface dialog) { |
| if (DBG) log("RespondViaSmsCancelListener.onCancel()..."); |
| |
| dismissPopup(); |
| |
| final PhoneConstants.State state = PhoneGlobals.getInstance().mCM.getState(); |
| if (state == PhoneConstants.State.IDLE) { |
| // This means the incoming call is already hung up when the user chooses not to |
| // use "Respond via SMS" feature. Let's just exit the whole in-call screen. |
| PhoneGlobals.getInstance().dismissCallScreen(); |
| } else { |
| |
| // If the user cancels the popup, this presumably means that |
| // they didn't actually mean to bring up the "Respond via SMS" |
| // UI in the first place (and instead want to go back to the |
| // state where they can either answer or reject the call.) |
| // So restart the ringer and bring back the regular incoming |
| // call UI. |
| |
| // This will have no effect if the incoming call isn't still ringing. |
| PhoneGlobals.getInstance().notifier.restartRinger(); |
| |
| // We hid the GlowPadView widget way back in |
| // InCallTouchUi.onTrigger(), when the user first selected |
| // the "SMS" trigger. |
| // |
| // To bring it back, just force the entire InCallScreen to |
| // update itself based on the current telephony state. |
| // (Assuming the incoming call is still ringing, this will |
| // cause the incoming call widget to reappear.) |
| mInCallScreen.requestUpdateScreen(); |
| } |
| } |
| } |
| |
| private void sendTextToDefaultActivity(String phoneNumber, String message) { |
| if (DBG) log("sendTextToDefaultActivity()..."); |
| final PackageManager packageManager = mInCallScreen.getPackageManager(); |
| |
| // Check to see if the default component to receive this intent is already saved |
| // and check to see if it still has the corrent permissions. |
| final SharedPreferences prefs = mInCallScreen.getSharedPreferences(SHARED_PREFERENCES_NAME, |
| Context.MODE_PRIVATE); |
| final String flattenedName = prefs.getString(KEY_INSTANT_TEXT_DEFAULT_COMPONENT, null); |
| if (flattenedName != null) { |
| if (DBG) log("Default package was found." + flattenedName); |
| |
| final ComponentName componentName = ComponentName.unflattenFromString(flattenedName); |
| ServiceInfo serviceInfo = null; |
| try { |
| serviceInfo = packageManager.getServiceInfo(componentName, 0); |
| } catch (PackageManager.NameNotFoundException e) { |
| Log.w(TAG, "Default service does not have permission."); |
| } |
| |
| if (serviceInfo != null && |
| PERMISSION_SEND_RESPOND_VIA_MESSAGE.equals(serviceInfo.permission)) { |
| sendTextAndExit(phoneNumber, message, componentName, false); |
| return; |
| } else { |
| SharedPreferences.Editor editor = prefs.edit(); |
| editor.remove(KEY_INSTANT_TEXT_DEFAULT_COMPONENT); |
| editor.apply(); |
| } |
| } |
| |
| final ArrayList<ComponentName> componentsWithPermission = |
| getPackagesWithInstantTextPermission(); |
| |
| final int size = componentsWithPermission.size(); |
| if (size == 0) { |
| Log.e(TAG, "No appropriate package receiving the Intent. Don't send anything"); |
| onPostMessageSent(); |
| } else if (size == 1) { |
| sendTextAndExit(phoneNumber, message, componentsWithPermission.get(0), false); |
| } else { |
| showPackageSelectionDialog(phoneNumber, message, componentsWithPermission); |
| } |
| } |
| |
| /** |
| * Queries the System to determine what packages contain services that can handle the instant |
| * text response Action AND have permissions to do so. |
| */ |
| private ArrayList<ComponentName> getPackagesWithInstantTextPermission() { |
| PackageManager packageManager = mInCallScreen.getPackageManager(); |
| |
| ArrayList<ComponentName> componentsWithPermission = Lists.newArrayList(); |
| |
| // Get list of all services set up to handle the Instant Text intent. |
| final List<ResolveInfo> infos = packageManager.queryIntentServices( |
| getInstantTextIntent("", null, null), 0); |
| |
| // Collect all the valid services |
| for (ResolveInfo resolveInfo : infos) { |
| final ServiceInfo serviceInfo = resolveInfo.serviceInfo; |
| if (serviceInfo == null) { |
| Log.w(TAG, "Ignore package without proper service."); |
| continue; |
| } |
| |
| // A Service is valid only if it requires the permission |
| // PERMISSION_SEND_RESPOND_VIA_MESSAGE |
| if (PERMISSION_SEND_RESPOND_VIA_MESSAGE.equals(serviceInfo.permission)) { |
| componentsWithPermission.add(new ComponentName(serviceInfo.packageName, |
| serviceInfo.name)); |
| } |
| } |
| |
| return componentsWithPermission; |
| } |
| |
| private void showPackageSelectionDialog(String phoneNumber, String message, |
| List<ComponentName> components) { |
| if (DBG) log("showPackageSelectionDialog()..."); |
| |
| dismissPopup(); |
| |
| BaseAdapter adapter = new PackageSelectionAdapter(mInCallScreen, components); |
| |
| PackageClickListener clickListener = |
| new PackageClickListener(phoneNumber, message, components); |
| |
| final CharSequence title = mInCallScreen.getResources().getText( |
| com.android.internal.R.string.whichApplication); |
| LayoutInflater inflater = |
| (LayoutInflater) mInCallScreen.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| |
| final View view = inflater.inflate(com.android.internal.R.layout.always_use_checkbox, null); |
| final CheckBox alwaysUse = (CheckBox) view.findViewById( |
| com.android.internal.R.id.alwaysUse); |
| alwaysUse.setText(com.android.internal.R.string.alwaysUse); |
| alwaysUse.setOnCheckedChangeListener(clickListener); |
| |
| AlertDialog.Builder builder = new AlertDialog.Builder(mInCallScreen) |
| .setTitle(title) |
| .setCancelable(true) |
| .setOnCancelListener(new RespondViaSmsCancelListener()) |
| .setAdapter(adapter, clickListener) |
| .setView(view); |
| mPackageSelectionPopup = builder.create(); |
| mPackageSelectionPopup.show(); |
| } |
| |
| private class PackageSelectionAdapter extends BaseAdapter { |
| private final LayoutInflater mInflater; |
| private final List<ComponentName> mComponents; |
| |
| public PackageSelectionAdapter(Context context, List<ComponentName> components) { |
| mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| mComponents = components; |
| } |
| |
| @Override |
| public int getCount() { |
| return mComponents.size(); |
| } |
| |
| @Override |
| public Object getItem(int position) { |
| return mComponents.get(position); |
| } |
| |
| @Override |
| public long getItemId(int position) { |
| return position; |
| } |
| |
| @Override |
| public View getView(int position, View convertView, ViewGroup parent) { |
| if (convertView == null) { |
| convertView = mInflater.inflate( |
| com.android.internal.R.layout.resolve_list_item, parent, false); |
| } |
| |
| final ComponentName component = mComponents.get(position); |
| final String packageName = component.getPackageName(); |
| final PackageManager packageManager = mInCallScreen.getPackageManager(); |
| |
| // Set the application label |
| final TextView text = (TextView) convertView.findViewById( |
| com.android.internal.R.id.text1); |
| final TextView text2 = (TextView) convertView.findViewById( |
| com.android.internal.R.id.text2); |
| |
| // Reset any previous values |
| text.setText(""); |
| text2.setVisibility(View.GONE); |
| try { |
| final ApplicationInfo appInfo = packageManager.getApplicationInfo(packageName, 0); |
| final CharSequence label = packageManager.getApplicationLabel(appInfo); |
| if (label != null) { |
| text.setText(label); |
| } |
| } catch (PackageManager.NameNotFoundException e) { |
| Log.w(TAG, "Failed to load app label because package was not found."); |
| } |
| |
| // Set the application icon |
| final ImageView icon = (ImageView) convertView.findViewById(android.R.id.icon); |
| Drawable drawable = null; |
| try { |
| drawable = mInCallScreen.getPackageManager().getApplicationIcon(packageName); |
| } catch (PackageManager.NameNotFoundException e) { |
| Log.w(TAG, "Failed to load icon because it wasn't found."); |
| } |
| if (drawable == null) { |
| drawable = mInCallScreen.getPackageManager().getDefaultActivityIcon(); |
| } |
| icon.setImageDrawable(drawable); |
| ViewGroup.LayoutParams lp = (ViewGroup.LayoutParams) icon.getLayoutParams(); |
| lp.width = lp.height = getIconSize(); |
| |
| return convertView; |
| } |
| |
| } |
| |
| private class PackageClickListener implements DialogInterface.OnClickListener, |
| CompoundButton.OnCheckedChangeListener { |
| /** Phone number to send the SMS to. */ |
| final private String mPhoneNumber; |
| final private String mMessage; |
| final private List<ComponentName> mComponents; |
| private boolean mMakeDefault = false; |
| |
| public PackageClickListener(String phoneNumber, String message, |
| List<ComponentName> components) { |
| mPhoneNumber = phoneNumber; |
| mMessage = message; |
| mComponents = components; |
| } |
| |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| ComponentName component = mComponents.get(which); |
| sendTextAndExit(mPhoneNumber, mMessage, component, mMakeDefault); |
| } |
| |
| @Override |
| public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { |
| Log.i(TAG, "mMakeDefault : " + isChecked); |
| mMakeDefault = isChecked; |
| } |
| } |
| |
| private void sendTextAndExit(String phoneNumber, String message, ComponentName component, |
| boolean setDefaultComponent) { |
| // Send the selected message immediately with no user interaction. |
| sendText(phoneNumber, message, component); |
| |
| if (setDefaultComponent) { |
| final SharedPreferences prefs = mInCallScreen.getSharedPreferences( |
| SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE); |
| prefs.edit() |
| .putString(KEY_INSTANT_TEXT_DEFAULT_COMPONENT, component.flattenToString()) |
| .apply(); |
| } |
| |
| // ...and show a brief confirmation to the user (since |
| // otherwise it's hard to be sure that anything actually |
| // happened.) |
| final Resources res = mInCallScreen.getResources(); |
| final String formatString = res.getString(R.string.respond_via_sms_confirmation_format); |
| final String confirmationMsg = String.format(formatString, phoneNumber); |
| Toast.makeText(mInCallScreen, |
| confirmationMsg, |
| Toast.LENGTH_LONG).show(); |
| |
| // TODO: If the device is locked, this toast won't actually ever |
| // be visible! (That's because we're about to dismiss the call |
| // screen, which means that the device will return to the |
| // keyguard. But toasts aren't visible on top of the keyguard.) |
| // Possible fixes: |
| // (1) Is it possible to allow a specific Toast to be visible |
| // on top of the keyguard? |
| // (2) Artifically delay the dismissCallScreen() call by 3 |
| // seconds to allow the toast to be seen? |
| // (3) Don't use a toast at all; instead use a transient state |
| // of the InCallScreen (perhaps via the InCallUiState |
| // progressIndication feature), and have that state be |
| // visible for 3 seconds before calling dismissCallScreen(). |
| |
| onPostMessageSent(); |
| } |
| |
| /** |
| * Sends a text message without any interaction from the user. |
| */ |
| private void sendText(String phoneNumber, String message, ComponentName component) { |
| if (VDBG) log("sendText: number " |
| + phoneNumber + ", message '" + message + "'"); |
| |
| mInCallScreen.startService(getInstantTextIntent(phoneNumber, message, component)); |
| } |
| |
| private void onPostMessageSent() { |
| // At this point the user is done dealing with the incoming call, so |
| // there's no reason to keep it around. (It's also confusing for |
| // the "incoming call" icon in the status bar to still be visible.) |
| // So reject the call now. |
| mInCallScreen.hangupRingingCall(); |
| |
| dismissPopup(); |
| |
| final PhoneConstants.State state = PhoneGlobals.getInstance().mCM.getState(); |
| if (state == PhoneConstants.State.IDLE) { |
| // There's no other phone call to interact. Exit the entire in-call screen. |
| PhoneGlobals.getInstance().dismissCallScreen(); |
| } else { |
| // The user is still in the middle of other phone calls, so we should keep the |
| // in-call screen. |
| mInCallScreen.requestUpdateScreen(); |
| } |
| } |
| |
| /** |
| * Brings up the standard SMS compose UI. |
| */ |
| private void launchSmsCompose(String phoneNumber) { |
| if (VDBG) log("launchSmsCompose: number " + phoneNumber); |
| |
| Intent intent = getInstantTextIntent(phoneNumber, null, null); |
| |
| if (VDBG) log("- Launching SMS compose UI: " + intent); |
| mInCallScreen.startService(intent); |
| } |
| |
| /** |
| * @param phoneNumber Must not be null. |
| * @param message Can be null. If message is null, the returned Intent will be configured to |
| * launch the SMS compose UI. If non-null, the returned Intent will cause the specified message |
| * to be sent with no interaction from the user. |
| * @param component The component that should handle this intent. |
| * @return Service Intent for the instant response. |
| */ |
| private static Intent getInstantTextIntent(String phoneNumber, String message, |
| ComponentName component) { |
| final Uri uri = Uri.fromParts(Constants.SCHEME_SMSTO, phoneNumber, null); |
| Intent intent = new Intent(TelephonyManager.ACTION_RESPOND_VIA_MESSAGE, uri); |
| if (message != null) { |
| intent.putExtra(Intent.EXTRA_TEXT, message); |
| } else { |
| intent.putExtra("exit_on_sent", true); |
| intent.putExtra("showUI", true); |
| } |
| if (component != null) { |
| intent.setComponent(component); |
| } |
| return intent; |
| } |
| |
| /** |
| * Settings activity under "Call settings" to let you manage the |
| * canned responses; see respond_via_sms_settings.xml |
| */ |
| public static class Settings extends PreferenceActivity |
| implements Preference.OnPreferenceChangeListener { |
| @Override |
| protected void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| if (DBG) log("Settings: onCreate()..."); |
| |
| getPreferenceManager().setSharedPreferencesName(SHARED_PREFERENCES_NAME); |
| |
| // This preference screen is ultra-simple; it's just 4 plain |
| // <EditTextPreference>s, one for each of the 4 "canned responses". |
| // |
| // The only nontrivial thing we do here is copy the text value of |
| // each of those EditTextPreferences and use it as the preference's |
| // "title" as well, so that the user will immediately see all 4 |
| // strings when they arrive here. |
| // |
| // Also, listen for change events (since we'll need to update the |
| // title any time the user edits one of the strings.) |
| |
| addPreferencesFromResource(R.xml.respond_via_sms_settings); |
| |
| EditTextPreference pref; |
| pref = (EditTextPreference) findPreference(KEY_CANNED_RESPONSE_PREF_1); |
| pref.setTitle(pref.getText()); |
| pref.setOnPreferenceChangeListener(this); |
| |
| pref = (EditTextPreference) findPreference(KEY_CANNED_RESPONSE_PREF_2); |
| pref.setTitle(pref.getText()); |
| pref.setOnPreferenceChangeListener(this); |
| |
| pref = (EditTextPreference) findPreference(KEY_CANNED_RESPONSE_PREF_3); |
| pref.setTitle(pref.getText()); |
| pref.setOnPreferenceChangeListener(this); |
| |
| pref = (EditTextPreference) findPreference(KEY_CANNED_RESPONSE_PREF_4); |
| pref.setTitle(pref.getText()); |
| pref.setOnPreferenceChangeListener(this); |
| |
| ActionBar actionBar = getActionBar(); |
| if (actionBar != null) { |
| // android.R.id.home will be triggered in onOptionsItemSelected() |
| actionBar.setDisplayHomeAsUpEnabled(true); |
| } |
| } |
| |
| // Preference.OnPreferenceChangeListener implementation |
| @Override |
| public boolean onPreferenceChange(Preference preference, Object newValue) { |
| if (DBG) log("onPreferenceChange: key = " + preference.getKey()); |
| if (VDBG) log(" preference = '" + preference + "'"); |
| if (VDBG) log(" newValue = '" + newValue + "'"); |
| |
| EditTextPreference pref = (EditTextPreference) preference; |
| |
| // Copy the new text over to the title, just like in onCreate(). |
| // (Watch out: onPreferenceChange() is called *before* the |
| // Preference itself gets updated, so we need to use newValue here |
| // rather than pref.getText().) |
| pref.setTitle((String) newValue); |
| |
| return true; // means it's OK to update the state of the Preference with the new value |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| final int itemId = item.getItemId(); |
| switch (itemId) { |
| case android.R.id.home: |
| // See ActionBar#setDisplayHomeAsUpEnabled() |
| CallFeaturesSetting.goUpToTopLevelSetting(this); |
| return true; |
| case R.id.respond_via_message_reset: |
| // Reset the preferences settings |
| SharedPreferences prefs = getSharedPreferences( |
| SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE); |
| SharedPreferences.Editor editor = prefs.edit(); |
| editor.remove(KEY_INSTANT_TEXT_DEFAULT_COMPONENT); |
| editor.apply(); |
| |
| return true; |
| default: |
| } |
| return super.onOptionsItemSelected(item); |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| getMenuInflater().inflate(R.menu.respond_via_message_settings_menu, menu); |
| return super.onCreateOptionsMenu(menu); |
| } |
| } |
| |
| /** |
| * Read the (customizable) canned responses from SharedPreferences, |
| * or from defaults if the user has never actually brought up |
| * the Settings UI. |
| * |
| * This method does disk I/O (reading the SharedPreferences file) |
| * so don't call it from the main thread. |
| * |
| * @see RespondViaSmsManager.Settings |
| */ |
| private String[] loadCannedResponses() { |
| if (DBG) log("loadCannedResponses()..."); |
| |
| SharedPreferences prefs = mInCallScreen.getSharedPreferences(SHARED_PREFERENCES_NAME, |
| Context.MODE_PRIVATE); |
| final Resources res = mInCallScreen.getResources(); |
| |
| String[] responses = new String[NUM_CANNED_RESPONSES]; |
| |
| // Note the default values here must agree with the corresponding |
| // android:defaultValue attributes in respond_via_sms_settings.xml. |
| |
| responses[0] = prefs.getString(KEY_CANNED_RESPONSE_PREF_1, |
| res.getString(R.string.respond_via_sms_canned_response_1)); |
| responses[1] = prefs.getString(KEY_CANNED_RESPONSE_PREF_2, |
| res.getString(R.string.respond_via_sms_canned_response_2)); |
| responses[2] = prefs.getString(KEY_CANNED_RESPONSE_PREF_3, |
| res.getString(R.string.respond_via_sms_canned_response_3)); |
| responses[3] = prefs.getString(KEY_CANNED_RESPONSE_PREF_4, |
| res.getString(R.string.respond_via_sms_canned_response_4)); |
| return responses; |
| } |
| |
| /** |
| * @return true if the "Respond via SMS" feature should be enabled |
| * for the specified incoming call. |
| * |
| * The general rule is that we *do* allow "Respond via SMS" except for |
| * the few (relatively rare) cases where we know for sure it won't |
| * work, namely: |
| * - a bogus or blank incoming number |
| * - a call from a SIP address |
| * - a "call presentation" that doesn't allow the number to be revealed |
| * |
| * In all other cases, we allow the user to respond via SMS. |
| * |
| * Note that this behavior isn't perfect; for example we have no way |
| * to detect whether the incoming call is from a landline (with most |
| * networks at least), so we still enable this feature even though |
| * SMSes to that number will silently fail. |
| */ |
| public static boolean allowRespondViaSmsForCall(Context context, Call ringingCall) { |
| if (DBG) log("allowRespondViaSmsForCall(" + ringingCall + ")..."); |
| |
| // First some basic sanity checks: |
| if (ringingCall == null) { |
| Log.w(TAG, "allowRespondViaSmsForCall: null ringingCall!"); |
| return false; |
| } |
| if (!ringingCall.isRinging()) { |
| // The call is in some state other than INCOMING or WAITING! |
| // (This should almost never happen, but it *could* |
| // conceivably happen if the ringing call got disconnected by |
| // the network just *after* we got it from the CallManager.) |
| Log.w(TAG, "allowRespondViaSmsForCall: ringingCall not ringing! state = " |
| + ringingCall.getState()); |
| return false; |
| } |
| Connection conn = ringingCall.getLatestConnection(); |
| if (conn == null) { |
| // The call doesn't have any connections! (Again, this can |
| // happen if the ringing call disconnects at the exact right |
| // moment, but should almost never happen in practice.) |
| Log.w(TAG, "allowRespondViaSmsForCall: null Connection!"); |
| return false; |
| } |
| |
| // Check the incoming number: |
| final String number = conn.getAddress(); |
| if (DBG) log("- number: '" + number + "'"); |
| if (TextUtils.isEmpty(number)) { |
| Log.w(TAG, "allowRespondViaSmsForCall: no incoming number!"); |
| return false; |
| } |
| if (PhoneNumberUtils.isUriNumber(number)) { |
| // The incoming number is actually a URI (i.e. a SIP address), |
| // not a regular PSTN phone number, and we can't send SMSes to |
| // SIP addresses. |
| // (TODO: That might still be possible eventually, though. Is |
| // there some SIP-specific equivalent to sending a text message?) |
| Log.i(TAG, "allowRespondViaSmsForCall: incoming 'number' is a SIP address."); |
| return false; |
| } |
| |
| // Finally, check the "call presentation": |
| int presentation = conn.getNumberPresentation(); |
| if (DBG) log("- presentation: " + presentation); |
| if (presentation == PhoneConstants.PRESENTATION_RESTRICTED) { |
| // PRESENTATION_RESTRICTED means "caller-id blocked". |
| // The user isn't allowed to see the number in the first |
| // place, so obviously we can't let you send an SMS to it. |
| Log.i(TAG, "allowRespondViaSmsForCall: PRESENTATION_RESTRICTED."); |
| return false; |
| } |
| |
| // Allow the feature only when there's a destination for it. |
| if (context.getPackageManager().resolveService(getInstantTextIntent(number, null, null) , 0) |
| == null) { |
| return false; |
| } |
| |
| // TODO: with some carriers (in certain countries) you *can* actually |
| // tell whether a given number is a mobile phone or not. So in that |
| // case we could potentially return false here if the incoming call is |
| // from a land line. |
| |
| // If none of the above special cases apply, it's OK to enable the |
| // "Respond via SMS" feature. |
| return true; |
| } |
| |
| private int getIconSize() { |
| if (mIconSize < 0) { |
| final ActivityManager am = |
| (ActivityManager) mInCallScreen.getSystemService(Context.ACTIVITY_SERVICE); |
| mIconSize = am.getLauncherLargeIconSize(); |
| } |
| |
| return mIconSize; |
| } |
| |
| |
| private static void log(String msg) { |
| Log.d(TAG, msg); |
| } |
| } |
