android.view.animation.BaseInterpolator#com.android.internal.R源码实例Demo

private static void loadTransitionOverride(Context context,
        RemoteViews.OnClickHandler handler) {
    if (handler != null && context.getResources().getBoolean(
            com.android.internal.R.bool.config_overrideRemoteViewsActivityTransition)) {
        TypedArray windowStyle = context.getTheme().obtainStyledAttributes(
                com.android.internal.R.styleable.Window);
        int windowAnimations = windowStyle.getResourceId(
                com.android.internal.R.styleable.Window_windowAnimationStyle, 0);
        TypedArray windowAnimationStyle = context.obtainStyledAttributes(
                windowAnimations, com.android.internal.R.styleable.WindowAnimation);
        handler.setEnterAnimationId(windowAnimationStyle.getResourceId(
                com.android.internal.R.styleable.
                        WindowAnimation_activityOpenRemoteViewsEnterAnimation, 0));
        windowStyle.recycle();
        windowAnimationStyle.recycle();
    }
}
 

/**
 * Creates an overlay with a background color and a thumbnail for the cross profile apps
 * animation.
 */
GraphicBuffer createCrossProfileAppsThumbnail(
        @DrawableRes int thumbnailDrawableRes, Rect frame) {
    final int width = frame.width();
    final int height = frame.height();

    final Picture picture = new Picture();
    final Canvas canvas = picture.beginRecording(width, height);
    canvas.drawColor(Color.argb(0.6f, 0, 0, 0));
    final int thumbnailSize = mService.mContext.getResources().getDimensionPixelSize(
            com.android.internal.R.dimen.cross_profile_apps_thumbnail_size);
    final Drawable drawable = mService.mContext.getDrawable(thumbnailDrawableRes);
    drawable.setBounds(
            (width - thumbnailSize) / 2,
            (height - thumbnailSize) / 2,
            (width + thumbnailSize) / 2,
            (height + thumbnailSize) / 2);
    drawable.setTint(mContext.getColor(android.R.color.white));
    drawable.draw(canvas);
    picture.endRecording();

    return Bitmap.createBitmap(picture).createGraphicBufferHandle();
}
 

private DatePickerDialog(@NonNull Context context, @StyleRes int themeResId,
        @Nullable OnDateSetListener listener, @Nullable Calendar calendar, int year,
        int monthOfYear, int dayOfMonth) {
    super(context, resolveDialogTheme(context, themeResId));

    final Context themeContext = getContext();
    final LayoutInflater inflater = LayoutInflater.from(themeContext);
    final View view = inflater.inflate(R.layout.date_picker_dialog, null);
    setView(view);

    setButton(BUTTON_POSITIVE, themeContext.getString(R.string.ok), this);
    setButton(BUTTON_NEGATIVE, themeContext.getString(R.string.cancel), this);
    setButtonPanelLayoutHint(LAYOUT_HINT_SIDE);

    if (calendar != null) {
        year = calendar.get(Calendar.YEAR);
        monthOfYear = calendar.get(Calendar.MONTH);
        dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
    }

    mDatePicker = (DatePicker) view.findViewById(R.id.datePicker);
    mDatePicker.init(year, monthOfYear, dayOfMonth, this);
    mDatePicker.setValidationCallback(mValidationCallback);

    mDateSetListener = listener;
}
 

/**
 * Retrieve the Bluetooth Adapter's name and address and save it in
 * in the local cache
 */
private void loadStoredNameAndAddress() {
    if (DBG) {
        Slog.d(TAG, "Loading stored name and address");
    }
    if (mContext.getResources()
            .getBoolean(com.android.internal.R.bool.config_bluetooth_address_validation)
            && Settings.Secure.getInt(mContentResolver, SECURE_SETTINGS_BLUETOOTH_ADDR_VALID, 0)
            == 0) {
        // if the valid flag is not set, don't load the address and name
        if (DBG) {
            Slog.d(TAG, "invalid bluetooth name and address stored");
        }
        return;
    }
    mName = Settings.Secure.getString(mContentResolver, SECURE_SETTINGS_BLUETOOTH_NAME);
    mAddress = Settings.Secure.getString(mContentResolver, SECURE_SETTINGS_BLUETOOTH_ADDRESS);
    if (DBG) {
        Slog.d(TAG, "Stored bluetooth Name=" + mName + ",Address=" + mAddress);
    }
}
 

private static FontFileResourceEntry readFont(XmlPullParser parser, Resources resources)
        throws XmlPullParserException, IOException {
    AttributeSet attrs = Xml.asAttributeSet(parser);
    TypedArray array = resources.obtainAttributes(attrs, R.styleable.FontFamilyFont);
    int weight = array.getInt(R.styleable.FontFamilyFont_fontWeight,
            Typeface.RESOLVE_BY_FONT_TABLE);
    int italic = array.getInt(R.styleable.FontFamilyFont_fontStyle,
            Typeface.RESOLVE_BY_FONT_TABLE);
    String variationSettings = array.getString(
            R.styleable.FontFamilyFont_fontVariationSettings);
    int ttcIndex = array.getInt(R.styleable.FontFamilyFont_ttcIndex, 0);
    String filename = array.getString(R.styleable.FontFamilyFont_font);
    array.recycle();
    while (parser.next() != XmlPullParser.END_TAG) {
        skip(parser);
    }
    if (filename == null) {
        return null;
    }
    return new FontFileResourceEntry(filename, weight, italic, variationSettings, ttcIndex);
}
 

/**
 * Should only be called if we've already verified that mProgressDrawable
 * and mProgressTintInfo are non-null.
 */
private void applyPrimaryProgressTint() {
    if (mProgressTintInfo.mHasProgressTint
            || mProgressTintInfo.mHasProgressTintMode) {
        final Drawable target = getTintTarget(R.id.progress, true);
        if (target != null) {
            if (mProgressTintInfo.mHasProgressTint) {
                target.setTintList(mProgressTintInfo.mProgressTintList);
            }
            if (mProgressTintInfo.mHasProgressTintMode) {
                target.setTintMode(mProgressTintInfo.mProgressTintMode);
            }

            // The drawable (or one of its children) may not have been
            // stateful before applying the tint, so let's try again.
            if (target.isStateful()) {
                target.setState(getDrawableState());
            }
        }
    }
}
 

@Override
void onVisualProgressChanged(int id, float scale) {
    super.onVisualProgressChanged(id, scale);

    if (id == R.id.progress) {
        final Drawable thumb = mThumb;
        if (thumb != null) {
            setThumbPos(getWidth(), thumb, scale, Integer.MIN_VALUE);

            // Since we draw translated, the drawable's bounds that it signals
            // for invalidation won't be the actual bounds we want invalidated,
            // so just invalidate this whole view.
            invalidate();
        }
    }
}
 

private Action getLockdownAction() {
    return new SinglePressAction(com.android.internal.R.drawable.ic_lock_lock,
            R.string.global_action_lockdown) {

        @Override
        public void onPress() {
            new LockPatternUtils(mContext).requireCredentialEntry(UserHandle.USER_ALL);
            try {
                WindowManagerGlobal.getWindowManagerService().lockNow(null);
            } catch (RemoteException e) {
                Log.e(TAG, "Error while trying to lock device.", e);
            }
        }

        @Override
        public boolean showDuringKeyguard() {
            return true;
        }

        @Override
        public boolean showBeforeProvisioning() {
            return false;
        }
    };
}
 

static @StyleRes int resolveDialogTheme(Context context, @StyleRes int themeResId) {
    if (themeResId == THEME_TRADITIONAL) {
        return R.style.Theme_Dialog_Alert;
    } else if (themeResId == THEME_HOLO_DARK) {
        return R.style.Theme_Holo_Dialog_Alert;
    } else if (themeResId == THEME_HOLO_LIGHT) {
        return R.style.Theme_Holo_Light_Dialog_Alert;
    } else if (themeResId == THEME_DEVICE_DEFAULT_DARK) {
        return R.style.Theme_DeviceDefault_Dialog_Alert;
    } else if (themeResId == THEME_DEVICE_DEFAULT_LIGHT) {
        return R.style.Theme_DeviceDefault_Light_Dialog_Alert;
    } else if (ResourceId.isValid(themeResId)) {
        // start of real resource IDs.
        return themeResId;
    } else {
        final TypedValue outValue = new TypedValue();
        context.getTheme().resolveAttribute(R.attr.alertDialogTheme, outValue, true);
        return outValue.resourceId;
    }
}
 

public WindowManager.LayoutParams getClingWindowLayoutParams() {
    final WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
            ViewGroup.LayoutParams.MATCH_PARENT,
            ViewGroup.LayoutParams.MATCH_PARENT,
            WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL,
            0
                    | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                    | WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED
                    | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
            ,
            PixelFormat.TRANSLUCENT);
    lp.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
    lp.setTitle("ImmersiveModeConfirmation");
    lp.windowAnimations = com.android.internal.R.style.Animation_ImmersiveModeConfirmation;
    lp.token = getWindowToken();
    return lp;
}
 

/**
 * Should only be called if we've already verified that mProgressDrawable
 * and mProgressTintInfo are non-null.
 */
private void applySecondaryProgressTint() {
    if (mProgressTintInfo.mHasSecondaryProgressTint
            || mProgressTintInfo.mHasSecondaryProgressTintMode) {
        final Drawable target = getTintTarget(R.id.secondaryProgress, false);
        if (target != null) {
            if (mProgressTintInfo.mHasSecondaryProgressTint) {
                target.setTintList(mProgressTintInfo.mSecondaryProgressTintList);
            }
            if (mProgressTintInfo.mHasSecondaryProgressTintMode) {
                target.setTintMode(mProgressTintInfo.mSecondaryProgressTintMode);
            }

            // The drawable (or one of its children) may not have been
            // stateful before applying the tint, so let's try again.
            if (target.isStateful()) {
                target.setState(getDrawableState());
            }
        }
    }
}
 

@Override
public void onFocusChange(View v, boolean focused) {
    if (focused) {
        switch (v.getId()) {
            case R.id.am_label:
                setAmOrPm(AM);
                break;
            case R.id.pm_label:
                setAmOrPm(PM);
                break;
            case R.id.hours:
                setCurrentItemShowing(HOUR_INDEX, true, true);
                break;
            case R.id.minutes:
                setCurrentItemShowing(MINUTE_INDEX, true, true);
                break;
            default:
                // Failed to handle this click, don't vibrate.
                return;
        }

        tryVibrate();
    }
}
 

public static void schedule(Context context) {
    int keepPreloadsMinDays = Resources.getSystem().getInteger(
            R.integer.config_keepPreloadsMinDays); // Default is 1 week
    long keepPreloadsMinTimeoutMs = DEBUG ? TimeUnit.MINUTES.toMillis(2)
            : TimeUnit.DAYS.toMillis(keepPreloadsMinDays);
    long keepPreloadsMaxTimeoutMs = DEBUG ? TimeUnit.MINUTES.toMillis(3)
            : TimeUnit.DAYS.toMillis(keepPreloadsMinDays + 1);

    if (DEBUG) {
        StringBuilder sb = new StringBuilder("Scheduling expiration job to run in ");
        TimeUtils.formatDuration(keepPreloadsMinTimeoutMs, sb);
        Slog.i(TAG, sb.toString());
    }
    JobInfo expirationJob = new JobInfo.Builder(JOB_ID,
            new ComponentName(context, PreloadsFileCacheExpirationJobService.class))
            .setPersisted(true)
            .setMinimumLatency(keepPreloadsMinTimeoutMs)
            .setOverrideDeadline(keepPreloadsMaxTimeoutMs)
            .build();

    JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
    jobScheduler.schedule(expirationJob);
}
 

@VisibleForTesting
public boolean isNotificationEnabled(NetworkAgentInfo fromNai, NetworkAgentInfo toNai) {
    // TODO: Evaluate moving to CarrierConfigManager.
    String[] notifySwitches =
            mContext.getResources().getStringArray(R.array.config_networkNotifySwitches);

    if (VDBG) {
        Log.d(TAG, "Notify on network switches: " + Arrays.toString(notifySwitches));
    }

    for (String notifySwitch : notifySwitches) {
        if (TextUtils.isEmpty(notifySwitch)) continue;
        String[] transports = notifySwitch.split("-", 2);
        if (transports.length != 2) {
            Log.e(TAG, "Invalid network switch notification configuration: " + notifySwitch);
            continue;
        }
        int fromTransport = TRANSPORT_NAMES.get("TRANSPORT_" + transports[0]);
        int toTransport = TRANSPORT_NAMES.get("TRANSPORT_" + transports[1]);
        if (hasTransport(fromNai, fromTransport) && hasTransport(toNai, toTransport)) {
            return true;
        }
    }

    return false;
}
 

/**
 * {@inheritDoc}
 */
public RadioGroup(Context context, AttributeSet attrs) {
    super(context, attrs);

    // RadioGroup is important by default, unless app developer overrode attribute.
    if (getImportantForAutofill() == IMPORTANT_FOR_AUTOFILL_AUTO) {
        setImportantForAutofill(IMPORTANT_FOR_AUTOFILL_YES);
    }

    // retrieve selected radio button as requested by the user in the
    // XML layout file
    TypedArray attributes = context.obtainStyledAttributes(
            attrs, com.android.internal.R.styleable.RadioGroup, com.android.internal.R.attr.radioButtonStyle, 0);

    int value = attributes.getResourceId(R.styleable.RadioGroup_checkedButton, View.NO_ID);
    if (value != View.NO_ID) {
        mCheckedId = value;
        mInitialCheckedId = value;
    }
    final int index = attributes.getInt(com.android.internal.R.styleable.RadioGroup_orientation, VERTICAL);
    setOrientation(index);

    attributes.recycle();
    init();
}
 

/**
 * {@inheritDoc}
 */
@Override
public View onCreateActionView() {
    // Create the view and set its data model.
    ActivityChooserView activityChooserView = new ActivityChooserView(mContext);
    if (!activityChooserView.isInEditMode()) {
        ActivityChooserModel dataModel = ActivityChooserModel.get(mContext, mShareHistoryFileName);
        activityChooserView.setActivityChooserModel(dataModel);
    }

    // Lookup and set the expand action icon.
    TypedValue outTypedValue = new TypedValue();
    mContext.getTheme().resolveAttribute(R.attr.actionModeShareDrawable, outTypedValue, true);
    Drawable drawable = mContext.getDrawable(outTypedValue.resourceId);
    activityChooserView.setExpandActivityOverflowButtonDrawable(drawable);
    activityChooserView.setProvider(this);

    // Set content description.
    activityChooserView.setDefaultActionButtonContentDescription(
            R.string.shareactionprovider_share_with_application);
    activityChooserView.setExpandActivityOverflowButtonContentDescription(
            R.string.shareactionprovider_share_with);

    return activityChooserView;
}
 

public YearPickerView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);

    final LayoutParams frame = new LayoutParams(
            LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
    setLayoutParams(frame);

    final Resources res = context.getResources();
    mViewSize = res.getDimensionPixelOffset(R.dimen.datepicker_view_animator_height);
    mChildSize = res.getDimensionPixelOffset(R.dimen.datepicker_year_label_height);

    setOnItemClickListener(new OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            final int year = mAdapter.getYearForPosition(position);
            mAdapter.setSelection(year);

            if (mOnYearSelectedListener != null) {
                mOnYearSelectedListener.onYearChanged(YearPickerView.this, year);
            }
        }
    });

    mAdapter = new YearAdapter(getContext());
    setAdapter(mAdapter);
}
 

private void showNotification(int titleRes, int iconRes) {
    final Notification.Builder builder =
            new Notification.Builder(mContext, SystemNotificationChannels.VPN)
                    .setWhen(0)
                    .setSmallIcon(iconRes)
                    .setContentTitle(mContext.getString(titleRes))
                    .setContentText(mContext.getString(R.string.vpn_lockdown_config))
                    .setContentIntent(mConfigIntent)
                    .setOngoing(true)
                    .addAction(R.drawable.ic_menu_refresh, mContext.getString(R.string.reset),
                            mResetIntent)
                    .setColor(mContext.getColor(
                            com.android.internal.R.color.system_notification_accent_color));

    NotificationManager.from(mContext).notify(null, SystemMessage.NOTE_VPN_STATUS,
            builder.build());
}
 

private static int inferValueTypeOfKeyframe(Resources res, Theme theme, AttributeSet attrs) {
    int valueType;
    TypedArray a;
    if (theme != null) {
        a = theme.obtainStyledAttributes(attrs, R.styleable.Keyframe, 0, 0);
    } else {
        a = res.obtainAttributes(attrs, R.styleable.Keyframe);
    }

    TypedValue keyframeValue = a.peekValue(R.styleable.Keyframe_value);
    boolean hasValue = (keyframeValue != null);
    // When no value type is provided, check whether it's a color type first.
    // If not, fall back to default value type (i.e. float type).
    if (hasValue && isColorType(keyframeValue.type)) {
        valueType = VALUE_TYPE_COLOR;
    } else {
        valueType = VALUE_TYPE_FLOAT;
    }
    a.recycle();
    return valueType;
}
 

@Override
public void onAnimationCancel(Animator animation) {
    if (mTransitionPosition == null) {
        mTransitionPosition = new int[2];
    }
    mTransitionPosition[0] = Math.round(mStartX + mMovingView.getTranslationX());
    mTransitionPosition[1] = Math.round(mStartY + mMovingView.getTranslationY());
    mViewInHierarchy.setTagInternal(R.id.transitionPosition, mTransitionPosition);
}
 

public DisplayMagnifier(WindowManagerService windowManagerService,
        MagnificationCallbacks callbacks) {
    mContext = windowManagerService.mContext;
    mService = windowManagerService;
    mCallbacks = callbacks;
    mHandler = new MyHandler(mService.mH.getLooper());
    mMagnifedViewport = new MagnifiedViewport();
    mLongAnimationDuration = mContext.getResources().getInteger(
            com.android.internal.R.integer.config_longAnimTime);
}
 

public ViewportWindow(Context context) {
    SurfaceControl surfaceControl = null;
    try {
        mWindowManager.getDefaultDisplay().getRealSize(mTempPoint);
        surfaceControl = mService.getDefaultDisplayContentLocked().makeOverlay()
                .setName(SURFACE_TITLE)
                .setSize(mTempPoint.x, mTempPoint.y) // not a typo
                .setFormat(PixelFormat.TRANSLUCENT)
                .build();
    } catch (OutOfResourcesException oore) {
        /* ignore */
    }
    mSurfaceControl = surfaceControl;
    mSurfaceControl.setLayer(mService.mPolicy.getWindowLayerFromTypeLw(
            TYPE_MAGNIFICATION_OVERLAY)
            * WindowManagerService.TYPE_LAYER_MULTIPLIER);
    mSurfaceControl.setPosition(0, 0);
    mSurface.copyFrom(mSurfaceControl);

    mAnimationController = new AnimationController(context,
            mService.mH.getLooper());

    TypedValue typedValue = new TypedValue();
    context.getTheme().resolveAttribute(R.attr.colorActivatedHighlight,
            typedValue, true);
    final int borderColor = context.getColor(typedValue.resourceId);

    mPaint.setStyle(Paint.Style.STROKE);
    mPaint.setStrokeWidth(mBorderWidth);
    mPaint.setColor(borderColor);

    mInvalidated = true;
}
 

/**
 * Attaches a surface with a thumbnail for the
 * {@link android.app.ActivityOptions#ANIM_OPEN_CROSS_PROFILE_APPS} animation.
 */
void attachCrossProfileAppsThumbnailAnimation() {
    if (!isReallyAnimating()) {
        return;
    }
    clearThumbnail();

    final WindowState win = findMainWindow();
    if (win == null) {
        return;
    }
    final Rect frame = win.mFrame;
    final int thumbnailDrawableRes = getTask().mUserId == mService.mCurrentUserId
            ? R.drawable.ic_account_circle
            : R.drawable.ic_corp_badge;
    final GraphicBuffer thumbnail =
            mService.mAppTransition
                    .createCrossProfileAppsThumbnail(thumbnailDrawableRes, frame);
    if (thumbnail == null) {
        return;
    }
    mThumbnail = new AppWindowThumbnail(getPendingTransaction(), this, thumbnail);
    final Animation animation =
            mService.mAppTransition.createCrossProfileAppsThumbnailAnimationLocked(win.mFrame);
    mThumbnail.startAnimation(getPendingTransaction(), animation, new Point(frame.left,
            frame.top));
}
 

public LayoutParams(@NonNull Context c, @Nullable AttributeSet attrs) {
    super(c, attrs);

    final TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.FrameLayout_Layout);
    gravity = a.getInt(R.styleable.FrameLayout_Layout_layout_gravity, UNSPECIFIED_GRAVITY);
    a.recycle();
}
 

@Override
public void onStart() {
    try {
        final Class<? extends IWallpaperManagerService> klass =
                (Class<? extends IWallpaperManagerService>)Class.forName(
                        getContext().getResources().getString(
                                R.string.config_wallpaperManagerServiceName));
        mService = klass.getConstructor(Context.class).newInstance(getContext());
        publishBinderService(Context.WALLPAPER_SERVICE, mService);
    } catch (Exception exp) {
        Slog.wtf(TAG, "Failed to instantiate WallpaperManagerService", exp);
    }
}
 

public WallpaperManagerService(Context context) {
    if (DEBUG) Slog.v(TAG, "WallpaperService startup");
    mContext = context;
    mShuttingDown = false;
    mImageWallpaper = ComponentName.unflattenFromString(
            context.getResources().getString(R.string.image_wallpaper_component));
    mDefaultWallpaperComponent = WallpaperManager.getDefaultWallpaperComponent(context);
    mIWindowManager = IWindowManager.Stub.asInterface(
            ServiceManager.getService(Context.WINDOW_SERVICE));
    mIPackageManager = AppGlobals.getPackageManager();
    mAppOpsManager = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
    mMonitor = new MyPackageMonitor();
    mColorsChangedListeners = new SparseArray<>();
}
 

private void initFromAttributes(
        Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    final TypedArray a = context.obtainStyledAttributes(
            attrs, R.styleable.RelativeLayout, defStyleAttr, defStyleRes);
    mIgnoreGravity = a.getResourceId(R.styleable.RelativeLayout_ignoreGravity, View.NO_ID);
    mGravity = a.getInt(R.styleable.RelativeLayout_gravity, mGravity);
    a.recycle();
}
 

/**
 * <p>Creates a new TableLayout for the given context and with the
 * specified set attributes.</p>
 *
 * @param context the application environment
 * @param attrs a collection of attributes
 */
public TableLayout(Context context, AttributeSet attrs) {
    super(context, attrs);

    TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.TableLayout);

    String stretchedColumns = a.getString(R.styleable.TableLayout_stretchColumns);
    if (stretchedColumns != null) {
        if (stretchedColumns.charAt(0) == '*') {
            mStretchAllColumns = true;
        } else {
            mStretchableColumns = parseColumns(stretchedColumns);
        }
    }

    String shrinkedColumns = a.getString(R.styleable.TableLayout_shrinkColumns);
    if (shrinkedColumns != null) {
        if (shrinkedColumns.charAt(0) == '*') {
            mShrinkAllColumns = true;
        } else {
            mShrinkableColumns = parseColumns(shrinkedColumns);
        }
    }

    String collapsedColumns = a.getString(R.styleable.TableLayout_collapseColumns);
    if (collapsedColumns != null) {
        mCollapsedColumns = parseColumns(collapsedColumns);
    }

    a.recycle();
    initTableLayout();
}
 

public SilentModeToggleAction() {
    super(R.drawable.ic_audio_vol_mute,
            R.drawable.ic_audio_vol,
            R.string.global_action_toggle_silent_mode,
            R.string.global_action_silent_mode_on_status,
            R.string.global_action_silent_mode_off_status);
}
 

/** @hide */
public AnticipateInterpolator(Resources res, Theme theme, AttributeSet attrs) {
    TypedArray a;
    if (theme != null) {
        a = theme.obtainStyledAttributes(attrs, R.styleable.AnticipateInterpolator, 0, 0);
    } else {
        a = res.obtainAttributes(attrs, R.styleable.AnticipateInterpolator);
    }

    mTension = a.getFloat(R.styleable.AnticipateInterpolator_tension, 2.0f);
    setChangingConfiguration(a.getChangingConfigurations());
    a.recycle();
}