Home | History | Annotate | Download | only in launcher3 
      1 /*
      2  * Copyright (C) 2015 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 package com.android.launcher3;
     17 
     18 import android.content.Context;
     19 import android.text.TextUtils;
     20 import android.util.AttributeSet;
     21 import android.view.DragEvent;
     22 import android.view.KeyEvent;
     23 import android.view.View;
     24 import android.view.inputmethod.InputMethodManager;
     25 import android.widget.EditText;
     26 
     27 import com.android.launcher3.util.UiThreadHelper;
     28 
     29 
     30 /**
     31  * The edit text that reports back when the back key has been pressed.
     32  */
     33 public class ExtendedEditText extends EditText {
     34 
     35     private boolean mShowImeAfterFirstLayout;
     36     private boolean mForceDisableSuggestions = false;
     37 
     38     /**
     39      * Implemented by listeners of the back key.
     40      */
     41     public interface OnBackKeyListener {
     42         public boolean onBackKey();
     43     }
     44 
     45     private OnBackKeyListener mBackKeyListener;
     46 
     47     public ExtendedEditText(Context context) {
     48         // ctor chaining breaks the touch handling
     49         super(context);
     50     }
     51 
     52     public ExtendedEditText(Context context, AttributeSet attrs) {
     53         // ctor chaining breaks the touch handling
     54         super(context, attrs);
     55     }
     56 
     57     public ExtendedEditText(Context context, AttributeSet attrs, int defStyleAttr) {
     58         super(context, attrs, defStyleAttr);
     59     }
     60 
     61     public void setOnBackKeyListener(OnBackKeyListener listener) {
     62         mBackKeyListener = listener;
     63     }
     64 
     65     @Override
     66     public boolean onKeyPreIme(int keyCode, KeyEvent event) {
     67         // If this is a back key, propagate the key back to the listener
     68         if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_UP) {
     69             if (mBackKeyListener != null) {
     70                 return mBackKeyListener.onBackKey();
     71             }
     72             return false;
     73         }
     74         return super.onKeyPreIme(keyCode, event);
     75     }
     76 
     77     @Override
     78     public boolean onDragEvent(DragEvent event) {
     79         // We don't want this view to interfere with Launcher own drag and drop.
     80         return false;
     81     }
     82 
     83     @Override
     84     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
     85         super.onLayout(changed, left, top, right, bottom);
     86         if (mShowImeAfterFirstLayout) {
     87             // soft input only shows one frame after the layout of the EditText happens,
     88             post(new Runnable() {
     89                 @Override
     90                 public void run() {
     91                     showSoftInput();
     92                     mShowImeAfterFirstLayout = false;
     93                 }
     94             });
     95         }
     96     }
     97 
     98     public void showKeyboard() {
     99         mShowImeAfterFirstLayout = !showSoftInput();
    100     }
    101 
    102     private boolean showSoftInput() {
    103         return requestFocus() &&
    104                 ((InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE))
    105                     .showSoftInput(this, InputMethodManager.SHOW_IMPLICIT);
    106     }
    107 
    108     public void dispatchBackKey() {
    109         UiThreadHelper.hideKeyboardAsync(getContext(), getWindowToken());
    110         if (mBackKeyListener != null) {
    111             mBackKeyListener.onBackKey();
    112         }
    113     }
    114 
    115     /**
    116      * Set to true when you want isSuggestionsEnabled to return false.
    117      * Use this to disable the red underlines that appear under typos when suggestions is enabled.
    118      */
    119     public void forceDisableSuggestions(boolean forceDisableSuggestions) {
    120         mForceDisableSuggestions = forceDisableSuggestions;
    121     }
    122 
    123     @Override
    124     public boolean isSuggestionsEnabled() {
    125         return !mForceDisableSuggestions && super.isSuggestionsEnabled();
    126     }
    127 
    128     public void reset() {
    129         if (!TextUtils.isEmpty(getText())) {
    130             setText("");
    131         }
    132         if (isFocused()) {
    133             View nextFocus = focusSearch(View.FOCUS_DOWN);
    134             if (nextFocus != null) {
    135                 nextFocus.requestFocus();
    136             }
    137         }
    138         UiThreadHelper.hideKeyboardAsync(getContext(), getWindowToken());
    139     }
    140 }
    141