title: Custom Typeface EditText Focus
body: <p>I'm using new features of lollipop such as <strong>coloraccent, colorPrimary</strong> in styles for pre-lollipop devices.</p>
  
  <p><strong>styles.xml</strong></p>
  
  <pre><code>&lt;resources&gt;
  
  &lt;style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar"&gt;
      &lt;item name="colorPrimary"&gt;@color/material_teal500&lt;/item&gt;
      &lt;item name="colorPrimaryDark"&gt;@color/material_teal600&lt;/item&gt;
      &lt;item name="colorAccent"&gt;@color/material_white&lt;/item&gt;
  &lt;/style&gt;
  </code></pre>
  
  <p></p>
  
  <p>Now I want to create a custom typeface for my textview, edittext and button. <strong>In styles i'm using coloraccent as white</strong>. So on focus of edittext white color should come. See the below image for default edittext focus. This works fine.</p>
  
  <p><img src="https://i.stack.imgur.com/FdeAL.png" alt="This is the picture of default edittext behavious"></p>
  
  <p>But whenever i create a custom typeface edittext the focus behavior is different. <strong>Its not showing the white color. Instead it showing in black color.</strong> See the below image for my custom edittext behavior for Email.</p>
  
  <p><img src="https://i.stack.imgur.com/0lYD7.png" alt="This is my custom edittext behaviour"></p>
  
  <p>This is my custom edittext typeface class.</p>
  
  <pre><code>public class TypefaceButton extends Button {
  
      /*
       * Permissible values ​​for the "typeface" attribute.
       */
      private final static int ROBOTO_THIN = 0;
      private final static int ROBOTO_THIN_ITALIC = 1;
      private final static int ROBOTO_LIGHT = 2;
      private final static int ROBOTO_LIGHT_ITALIC = 3;
      private final static int ROBOTO_REGULAR = 4;
      private final static int ROBOTO_ITALIC = 5;
      private final static int ROBOTO_MEDIUM = 6;
      private final static int ROBOTO_MEDIUM_ITALIC = 7;
      private final static int ROBOTO_BOLD = 8;
      private final static int ROBOTO_BOLD_ITALIC = 9;
      private final static int ROBOTO_BLACK = 10;
      private final static int ROBOTO_BLACK_ITALIC = 11;
      private final static int ROBOTO_CONDENSED = 12;
      private final static int ROBOTO_CONDENSED_ITALIC = 13;
      private final static int ROBOTO_CONDENSED_BOLD = 14;
      private final static int ROBOTO_CONDENSED_BOLD_ITALIC = 15;
      /**
       * List of created typefaces for later reused.
       */
      private final static SparseArray&lt;Typeface&gt; mTypefaces = new SparseArray&lt;Typeface&gt;(16);
  
      /**
       * Simple constructor to use when creating a view from code.
       *
       * @param context The Context the view is running in, through which it can
       *                access the current theme, resources, etc.
       */
      public TypefaceButton(Context context) {
          super(context);
      }
  
      /**
       * Constructor that is called when inflating a view from XML. This is called
       * when a view is being constructed from an XML file, supplying attributes
       * that were specified in the XML file. This version uses a default style of
       * 0, so the only attribute values applied are those in the Context's Theme
       * and the given AttributeSet.
       * &lt;p/&gt;
       * &lt;p/&gt;
       * The method onFinishInflate() will be called after all children have been
       * added.
       *
       * @param context The Context the view is running in, through which it can
       *                access the current theme, resources, etc.
       * @param attrs   The attributes of the XML tag that is inflating the view.
       * @see #TypefaceButton(android.content.Context, android.util.AttributeSet, int)
       */
      public TypefaceButton(Context context, AttributeSet attrs) {
          super(context, attrs);
          parseAttributes(context, attrs);
      }
  
      /**
       * Perform inflation from XML and apply a class-specific base style. This
       * constructor of View allows subclasses to use their own base style when
       * they are inflating.
       *
       * @param context  The Context the view is running in, through which it can
       *                 access the current theme, resources, etc.
       * @param attrs    The attributes of the XML tag that is inflating the view.
       * @param defStyle The default style to apply to this view. If 0, no style
       *                 will be applied (beyond what is included in the theme). This may
       *                 either be an attribute resource, whose value will be retrieved
       *                 from the current theme, or an explicit style resource.
       * @see #TypefaceButton(android.content.Context, android.util.AttributeSet)
       */
      public TypefaceButton(Context context, AttributeSet attrs, int defStyle) {
          super(context, attrs, defStyle);
          parseAttributes(context, attrs);
      }
  
      /**
       * Parse the attributes.
       *
       * @param context The Context the view is running in, through which it can access the current           theme, resources, etc.
       * @param attrs   The attributes of the XML tag that is inflating the view.
       */
      private void parseAttributes(Context context, AttributeSet attrs) {
          TypedArray values = context.obtainStyledAttributes(attrs, R.styleable.TypefaceTextView);
  
          int typefaceValue = values.getInt(R.styleable.TypefaceTextView_typeface, 0);
          values.recycle();
  
          setTypeface(obtaintTypeface(context, typefaceValue));
      }
  
      /**
       * Obtain typeface.
       *
       * @param context       The Context the view is running in, through which it can
       *                      access the current theme, resources, etc.
       * @param typefaceValue values ​​for the "typeface" attribute
       * @return Roboto {@link android.graphics.Typeface}
       * @throws IllegalArgumentException if unknown `typeface` attribute value.
       */
      private Typeface obtaintTypeface(Context context, int typefaceValue) throws IllegalArgumentException {
          Typeface typeface = mTypefaces.get(typefaceValue);
          if (typeface == null) {
              typeface = createTypeface(context, typefaceValue);
              mTypefaces.put(typefaceValue, typeface);
          }
          return typeface;
      }
  
      /**
       * Create typeface from assets.
       *
       * @param context       The Context the view is running in, through which it can
       *                      access the current theme, resources, etc.
       * @param typefaceValue values ​​for the "typeface" attribute
       * @return Roboto {@link android.graphics.Typeface}
       * @throws IllegalArgumentException if unknown `typeface` attribute value.
       */
      private Typeface createTypeface(Context context, int typefaceValue) throws IllegalArgumentException {
          Typeface typeface;
          switch (typefaceValue) {
              case ROBOTO_THIN:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Thin.ttf");
                  break;
              case ROBOTO_THIN_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-ThinItalic.ttf");
                  break;
              case ROBOTO_LIGHT:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Light.ttf");
                  break;
              case ROBOTO_LIGHT_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-LightItalic.ttf");
                  break;
              case ROBOTO_REGULAR:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Regular.ttf");
                  break;
              case ROBOTO_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Italic.ttf");
                  break;
              case ROBOTO_MEDIUM:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Medium.ttf");
                  break;
              case ROBOTO_MEDIUM_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-MediumItalic.ttf");
                  break;
              case ROBOTO_BOLD:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Bold.ttf");
                  break;
              case ROBOTO_BOLD_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BoldItalic.ttf");
                  break;
              case ROBOTO_BLACK:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Black.ttf");
                  break;
              case ROBOTO_BLACK_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BlackItalic.ttf");
                  break;
              case ROBOTO_CONDENSED:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-Condensed.ttf");
                  break;
              case ROBOTO_CONDENSED_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-CondensedItalic.ttf");
                  break;
              case ROBOTO_CONDENSED_BOLD:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BoldCondensed.ttf");
                  break;
              case ROBOTO_CONDENSED_BOLD_ITALIC:
                  typeface = Typeface.createFromAsset(context.getAssets(), "fonts/Roboto-BoldCondensedItalic.ttf");
                  break;
              default:
                  throw new IllegalArgumentException("Unknown `typeface` attribute value " + typefaceValue);
          }
          return typeface;
      }
  
  }
  </code></pre>
  
  <p>I used custom type face in xml like following.</p>
  
  <pre><code>&lt;appname.utilities.TypefaceEditText
          android:id="@+id/editText2"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_gravity="center_horizontal"
          android:layout_margin="@dimen/ten_dp"
          custom:typeface="roboto_light"
          android:ems="10"
          android:hint="@string/user_email"
          android:inputType="textEmailAddress"
          android:textColor="@color/material_grey200"
          android:textColorHint="@color/material_grey200" /&gt;
  </code></pre>
  
  <p>How i can resolve this! Any Idea? I know i can implement Custom Font in java class file. But I would like to implement in this way. In my own custom edit text also i want to show the same accent color. Thanks in prior!</p>