Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Copyright (C) 2007 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
 
17
 package android.view;
18
 
24
 
27
 
This class is used to instantiate layout XML file into its corresponding View objects. It is never be used directly -- use android.app.Activity.getLayoutInflater() or android.content.Context.getSystemService(java.lang.String) to retrieve a standard LayoutInflater instance that is already hooked up to the current context and correctly configured for the device you are running on. For example: 
LayoutInflater inflater = (LayoutInflater)context.getSystemService
      Context.LAYOUT_INFLATER_SERVICE);

To create a new LayoutInflater with an additional LayoutInflater.Factory for your own views, you can use cloneInContext(android.content.Context) to clone an existing ViewFactory, and then call setFactory(android.view.LayoutInflater.Factory) on it to include your Factory.

For performance reasons, view inflation relies heavily on pre-processing of XML files that is done at build time. Therefore, it is not currently possible to use LayoutInflater with an XmlPullParser over a plain XML file at runtime; it only works with an XmlPullParser returned from a compiled resource (R.something file.)

See also:
android.content.Context.getSystemService(java.lang.String)
57
 
58
 public abstract class LayoutInflater {
59
     private final boolean DEBUG = false;

    
This field should be made private, so it is hidden from the SDK. 
64
 
65
     protected final Context mContext;
66
 
67
     // these are optional, set by the caller
68
     private boolean mFactorySet;
69
     private Factory mFactory;
70
     private Filter mFilter;
71
 
72
     private final Object[] mConstructorArgs = new Object[2];
73
 
74
     private static final Class[] mConstructorSignature = new Class[] {
75
             Context.class, AttributeSet.class};
76
 
77
     private static final HashMap<String, Constructor> sConstructorMap =
78
             new HashMap<String, Constructor>();
79
     
80
     private HashMap<String, Boolean> mFilterMap;
81
 
82
     private static final String TAG_MERGE = "merge";
83
     private static final String TAG_INCLUDE = "include";
84
     private static final String TAG_REQUEST_FOCUS = "requestFocus";

    
Hook to allow clients of the LayoutInflater to restrict the set of Views that are allowed to be inflated. 
90
 
91
     public interface Filter {
        
Hook to allow clients of the LayoutInflater to restrict the set of Views that are allowed to be inflated.

Parameters:
clazz The class object for the View that is about to be inflated
Returns:
True if this class is allowed to be inflated, or false otherwise
99
 
100
        boolean onLoadClass(Class clazz);
101
    }
102
    
103
    public interface Factory {
        
Hook you can supply that is called when inflating from a LayoutInflater. You can use this to customize the tag names available in your XML layout files.

Note that it is good practice to prefix these custom names with your package (i.e., com.coolcompany.apps) to avoid conflicts with system names.

Parameters:
name Tag name to be inflated.
context The context the view is being created in.
attrs Inflation attributes as specified in XML file.
Returns:
View Newly created view. Return null for the default behavior.
121
        public View onCreateView(String name, Context context, AttributeSet attrs);
122
    }
124
    private static class FactoryMerger implements Factory {
125
        private final Factory mF1, mF2;
126
        
127
        FactoryMerger(Factory f1, Factory f2) {
128
             = f1;
129
             = f2;
130
        }
131
        
132
        public View onCreateView(String name, Context context, AttributeSet attrs) {
133
            View v = .onCreateView(name, context, attrs);
134
            if (v != null) return v;
135
            return .onCreateView(name, context, attrs);
136
        }
137
    }
    
    
Create a new LayoutInflater instance associated with a particular Context. Applications will almost always want to use Context.getSystemService() to retrieve the standard Context.INFLATER_SERVICE.

Parameters:
context The Context in which this LayoutInflater will create its Views; most importantly, this supplies the theme from which the default values for their attributes are retrieved.
149
    protected LayoutInflater(Context context) {
150
         = context;
151
    }

    
Create a new LayoutInflater instance that is a copy of an existing LayoutInflater, optionally with its Context changed. For use in implementing cloneInContext(android.content.Context).

Parameters:
original The original LayoutInflater to copy.
newContext The new Context to use.
161
    protected LayoutInflater(LayoutInflater original, Context newContext) {
162
         = newContext;
163
         = original.mFactory;
164
         = original.mFilter;
165
    }
    
    
Obtains the LayoutInflater from the given context. 
170
    public static LayoutInflater from(Context context) {
171
        LayoutInflater LayoutInflater =
172
                (LayoutInflater) context.getSystemService(.);
173
        if (LayoutInflater == null) {
174
            throw new AssertionError("LayoutInflater not found.");
175
        }
176
        return LayoutInflater;
177
    }

    
Create a copy of the existing LayoutInflater object, with the copy pointing to a different Context than the original. This is used by ContextThemeWrapper to create a new LayoutInflater to go along with the new Context theme.

Parameters:
newContext The new Context to associate with the new LayoutInflater. May be the same as the original Context if desired.
Returns:
Returns a brand spanking new LayoutInflater object associated with the given Context.
191
    public abstract LayoutInflater cloneInContext(Context newContext);
    
    
Return the context we are running in, for access to resources, class loader, etc. 
197
    public Context getContext() {
198
        return ;
199
    }

    
Return the current factory (or null). This is called on each element name. If the factory returns a View, add that to the hierarchy. If it returns null, proceed to call onCreateView(name). 
206
    public final Factory getFactory() {
207
        return ;
208
    }

    
Attach a custom Factory interface for creating views while using this LayoutInflater. This must not be null, and can only be set once; after setting, you can not change the factory. This is called on each element name as the xml is parsed. If the factory returns a View, that is added to the hierarchy. If it returns null, the next factory default onCreateView(java.lang.String,android.util.AttributeSet) method is called.

If you have an existing LayoutInflater and want to add your own factory to it, use cloneInContext(android.content.Context) to clone the existing instance and then you can use this function (once) on the returned new instance. This will merge your own factory with whatever factory the original instance is using. 

225
    public void setFactory(Factory factory) {
226
        if () {
227
            throw new IllegalStateException("A factory has already been set on this LayoutInflater");
228
        }
229
        if (factory == null) {
230
            throw new NullPointerException("Given factory can not be null");
231
        }
232
         = true;
233
        if ( == null) {
234
             = factory;
235
        } else {
236
             = new FactoryMerger(factory, );
237
        }
238
    }

    

Returns:
The LayoutInflater.Filter currently used by this LayoutInflater to restrict the set of Views that are allowed to be inflated.
244
    public Filter getFilter() {
245
        return ;
246
    }
    
    
Sets the LayoutInflater.Filter to by this LayoutInflater. If a view is attempted to be inflated which is not allowed by the LayoutInflater.Filter, the inflate(int,android.view.ViewGroup) call will throw an InflateException. This filter will replace any previous filter set on this LayoutInflater.

Parameters:
filter The Filter which restricts the set of Views that are allowed to be inflated. This filter will replace any previous filter set on this LayoutInflater.
257
    public void setFilter(Filter filter) {
258
         = filter;
259
        if (filter != null) {
260
             = new HashMap<String, Boolean>();
261
        }
262
    }

    
Inflate a new view hierarchy from the specified xml resource. Throws InflateException if there is an error.

Parameters:
resource ID for an XML layout resource to load (e.g., R.layout.main_page)
root Optional view to be the parent of the generated hierarchy.
Returns:
The root View of the inflated hierarchy. If root was supplied, this is the root View; otherwise it is the root of the inflated XML file.
275
    public View inflate(int resource, ViewGroup root) {
276
        return inflate(resource, root, root != null);
277
    }

    
Inflate a new view hierarchy from the specified xml node. Throws InflateException if there is an error. *

Important   For performance reasons, view inflation relies heavily on pre-processing of XML files that is done at build time. Therefore, it is not currently possible to use LayoutInflater with an XmlPullParser over a plain XML file at runtime.

Parameters:
parser XML dom node containing the description of the view hierarchy.
root Optional view to be the parent of the generated hierarchy.
Returns:
The root View of the inflated hierarchy. If root was supplied, this is the root View; otherwise it is the root of the inflated XML file.
295
    public View inflate(XmlPullParser parser, ViewGroup root) {
296
        return inflate(parser, root, root != null);
297
    }

    
Inflate a new view hierarchy from the specified xml resource. Throws InflateException if there is an error.

Parameters:
resource ID for an XML layout resource to load (e.g., R.layout.main_page)
root Optional view to be the parent of the generated hierarchy (if attachToRoot is true), or else simply an object that provides a set of LayoutParams values for root of the returned hierarchy (if attachToRoot is false.)
attachToRoot Whether the inflated hierarchy should be attached to the root parameter? If false, root is only used to create the correct subclass of LayoutParams for the root view in the XML.
Returns:
The root View of the inflated hierarchy. If root was supplied and attachToRoot is true, this is root; otherwise it is the root of the inflated XML file.
316
    public View inflate(int resource, ViewGroup root, boolean attachToRoot) {
317
        if () ..println("INFLATING from resource: " + resource);
318
        XmlResourceParser parser = getContext().getResources().getLayout(resource);
319
        try {
320
            return inflate(parser, root, attachToRoot);
321
        } finally {
322
            parser.close();
323
        }
324
    }

    
Inflate a new view hierarchy from the specified XML node. Throws InflateException if there is an error.

Important   For performance reasons, view inflation relies heavily on pre-processing of XML files that is done at build time. Therefore, it is not currently possible to use LayoutInflater with an XmlPullParser over a plain XML file at runtime.

Parameters:
parser XML dom node containing the description of the view hierarchy.
root Optional view to be the parent of the generated hierarchy (if attachToRoot is true), or else simply an object that provides a set of LayoutParams values for root of the returned hierarchy (if attachToRoot is false.)
attachToRoot Whether the inflated hierarchy should be attached to the root parameter? If false, root is only used to create the correct subclass of LayoutParams for the root view in the XML.
Returns:
The root View of the inflated hierarchy. If root was supplied and attachToRoot is true, this is root; otherwise it is the root of the inflated XML file.
348
    public View inflate(XmlPullParser parser, ViewGroup root, boolean attachToRoot) {
349
        synchronized () {
350
            final AttributeSet attrs = Xml.asAttributeSet(parser);
351
            Context lastContext = (Context)[0];
352
            [0] = ;
353
            View result = root;
355
            try {
356
                // Look for the root node.
357
                int type;
358
                while ((type = parser.next()) != . &&
359
                        type != .) {
360
                    // Empty
361
                }
363
                if (type != .) {
364
                    throw new InflateException(parser.getPositionDescription()
365
                            + ": No start tag found!");
366
                }
368
                final String name = parser.getName();
369
                
370
                if () {
371
                    ..println("**************************");
372
                    ..println("Creating root view: "
373
                            + name);
374
                    ..println("**************************");
375
                }
377
                if (.equals(name)) {
378
                    if (root == null || !attachToRoot) {
379
                        throw new InflateException("<merge /> can be used only with a valid "
380
                                + "ViewGroup root and attachToRoot=true");
381
                    }
383
                    rInflate(parser, root, attrs);
384
                } else {
385
                    // Temp is the root view that was found in the xml
386
                    View temp = createViewFromTag(name, attrs);
388
                    ViewGroup.LayoutParams params = null;
390
                    if (root != null) {
391
                        if () {
392
                            ..println("Creating params from root: " +
393
                                    root);
394
                        }
395
                        // Create layout params that match root, if supplied
396
                        params = root.generateLayoutParams(attrs);
397
                        if (!attachToRoot) {
398
                            // Set the layout params for temp if we are not
399
                            // attaching. (If we are, we use addView, below)
400
                            temp.setLayoutParams(params);
401
                        }
402
                    }
404
                    if () {
405
                        ..println("-----> start inflating children");
406
                    }
407
                    // Inflate all children under temp
408
                    rInflate(parser, temp, attrs);
409
                    if () {
410
                        ..println("-----> done inflating children");
411
                    }
413
                    // We are supposed to attach all the views we found (int temp)
414
                    // to root. Do that now.
415
                    if (root != null && attachToRoot) {
416
                        root.addView(temp, params);
417
                    }
419
                    // Decide whether to return the root that was passed in or the
420
                    // top view found in xml.
421
                    if (root == null || !attachToRoot) {
422
                        result = temp;
423
                    }
424
                }
426
            } catch (XmlPullParserException e) {
427
                InflateException ex = new InflateException(e.getMessage());
428
                ex.initCause(e);
429
                throw ex;
430
            } catch (IOException e) {
431
                InflateException ex = new InflateException(
432
                        parser.getPositionDescription()
433
                        + ": " + e.getMessage());
434
                ex.initCause(e);
435
                throw ex;
436
            } finally {
437
                // Don't retain static reference on context.
438
                [0] = lastContext;
439
                [1] = null;
440
            }
442
            return result;
443
        }
444
    }

    
Low-level function for instantiating a view by name. This attempts to instantiate a view class of the given name found in this LayoutInflater's ClassLoader.

There are two things that can happen in an error case: either the exception describing the error will be thrown, or a null will be returned. You must deal with both possibilities -- the former will happen the first time createView() is called for a class of a particular name, the latter every time there-after for that class name.

Parameters:
name The full name of the class to be instantiated.
attrs The XML attributes supplied for this instance.
Returns:
View The newly instantied view, or null.
463
    public final View createView(String name, String prefix, AttributeSet attrs)
464
            throws ClassNotFoundException, InflateException {
465
        Constructor constructor = .get(name);
466
        Class clazz = null;
468
        try {
469
            if (constructor == null) {
470
                // Class not found in the cache, see if it's real, and try to add it
471
                clazz = .getClassLoader().loadClass(
472
                        prefix != null ? (prefix + name) : name);
473
                
474
                if ( != null && clazz != null) {
475
                    boolean allowed = .onLoadClass(clazz);
476
                    if (!allowed) {
477
                        failNotAllowed(name, prefix, attrs);
478
                    }
479
                }
480
                constructor = clazz.getConstructor();
481
                .put(name, constructor);
482
            } else {
483
                // If we have a filter, apply it to cached constructor
484
                if ( != null) {
485
                    // Have we seen this name before?
486
                    Boolean allowedState = .get(name);
487
                    if (allowedState == null) {
488
                        // New class -- remember whether it is allowed
489
                        clazz = .getClassLoader().loadClass(
490
                                prefix != null ? (prefix + name) : name);
491
                        
492
                        boolean allowed = clazz != null && .onLoadClass(clazz);
493
                        .put(name, allowed);
494
                        if (!allowed) {
495
                            failNotAllowed(name, prefix, attrs);
496
                        }
497
                    } else if (allowedState.equals(.)) {
498
                        failNotAllowed(name, prefix, attrs);
499
                    }
500
                }
501
            }
503
            Object[] args = ;
504
            args[1] = attrs;
505
            return (View) constructor.newInstance(args);
507
        } catch (NoSuchMethodException e) {
508
            InflateException ie = new InflateException(attrs.getPositionDescription()
509
                    + ": Error inflating class "
510
                    + (prefix != null ? (prefix + name) : name));
511
            ie.initCause(e);
512
            throw ie;
514
        } catch (ClassNotFoundException e) {
515
            // If loadClass fails, we should propagate the exception.
516
            throw e;
517
        } catch (Exception e) {
518
            InflateException ie = new InflateException(attrs.getPositionDescription()
519
                    + ": Error inflating class "
520
                    + (clazz == null ? "<unknown>" : clazz.getName()));
521
            ie.initCause(e);
522
            throw ie;
523
        }
524
    }

    
Throw an excpetion because the specified class is not allowed to be inflated. 
529
    private void failNotAllowed(String name, String prefix, AttributeSet attrs) {
530
        InflateException ie = new InflateException(attrs.getPositionDescription()
531
                + ": Class not allowed to be inflated "
532
                + (prefix != null ? (prefix + name) : name));
533
        throw ie;
534
    }

    
This routine is responsible for creating the correct subclass of View given the xml element name. Override it to handle custom view objects. If you override this in your subclass be sure to call through to super.onCreateView(name) for names you do not recognize.

Parameters:
name The fully qualified class name of the View to be create.
attrs An AttributeSet of attributes to apply to the View.
Returns:
View The View created.
547
    protected View onCreateView(String name, AttributeSet attrs)
548
            throws ClassNotFoundException {
549
        return createView(name, "android.view.", attrs);
550
    }
552
    /*
553
     * default visibility so the BridgeInflater can override it.
554
     */
555
    View createViewFromTag(String name, AttributeSet attrs) {
556
        if (name.equals("view")) {
557
            name = attrs.getAttributeValue(null, "class");
558
        }
560
        if () ..println("******** Creating view: " + name);
562
        try {
563
            View view = ( == null) ? null : .onCreateView(name,
564
                    , attrs);
566
            if (view == null) {
567
                if (-1 == name.indexOf('.')) {
568
                    view = onCreateView(name, attrs);
569
                } else {
570
                    view = createView(name, null, attrs);
571
                }
572
            }
574
            if () ..println("Created view is: " + view);
575
            return view;
577
        } catch (InflateException e) {
578
            throw e;
580
        } catch (ClassNotFoundException e) {
581
            InflateException ie = new InflateException(attrs.getPositionDescription()
582
                    + ": Error inflating class " + name);
583
            ie.initCause(e);
584
            throw ie;
586
        } catch (Exception e) {
587
            InflateException ie = new InflateException(attrs.getPositionDescription()
588
                    + ": Error inflating class " + name);
589
            ie.initCause(e);
590
            throw ie;
591
        }
592
    }

    
Recursive method used to descend down the xml hierarchy and instantiate views, instantiate their children, and then call onFinishInflate(). 
598
    private void rInflate(XmlPullParser parser, View parent, final AttributeSet attrs)
599
            throws XmlPullParserException, IOException {
601
        final int depth = parser.getDepth();
602
        int type;
604
        while (((type = parser.next()) != . ||
605
                parser.getDepth() > depth) && type != .) {
607
            if (type != .) {
608
                continue;
609
            }
611
            final String name = parser.getName();
612
            
613
            if (.equals(name)) {
614
                parseRequestFocus(parser, parent);
615
            } else if (.equals(name)) {
616
                if (parser.getDepth() == 0) {
617
                    throw new InflateException("<include /> cannot be the root element");
618
                }
619
                parseInclude(parser, parent, attrs);
620
            } else if (.equals(name)) {
621
                throw new InflateException("<merge /> must be the root element");
622
            } else {
623
                final View view = createViewFromTag(name, attrs);
624
                final ViewGroup viewGroup = (ViewGroup) parent;
625
                final ViewGroup.LayoutParams params = viewGroup.generateLayoutParams(attrs);
626
                rInflate(parser, view, attrs);
627
                viewGroup.addView(view, params);
628
            }
629
        }
631
        parent.onFinishInflate();
632
    }
634
    private void parseRequestFocus(XmlPullParser parser, View parent)
635
            throws XmlPullParserException, IOException {
636
        int type;
637
        parent.requestFocus();
638
        final int currentDepth = parser.getDepth();
639
        while (((type = parser.next()) != . ||
640
                parser.getDepth() > currentDepth) && type != .) {
641
            // Empty
642
        }
643
    }
645
    private void parseInclude(XmlPullParser parser, View parent, AttributeSet attrs)
646
            throws XmlPullParserException, IOException {
648
        int type;
650
        if (parent instanceof ViewGroup) {
651
            final int layout = attrs.getAttributeResourceValue(null, "layout", 0);
652
            if (layout == 0) {
653
                final String value = attrs.getAttributeValue(null, "layout");
654
                if (value == null) {
655
                    throw new InflateException("You must specifiy a layout in the"
656
                            + " include tag: <include layout=\"@layout/layoutID\" />");
657
                } else {
658
                    throw new InflateException("You must specifiy a valid layout "
659
                            + "reference. The layout ID " + value + " is not valid.");
660
                }
661
            } else {
662
                final XmlResourceParser childParser =
663
                        getContext().getResources().getLayout(layout);
665
                try {
666
                    final AttributeSet childAttrs = Xml.asAttributeSet(childParser);
668
                    while ((type = childParser.next()) != . &&
669
                            type != .) {
670
                        // Empty.
671
                    }
673
                    if (type != .) {
674
                        throw new InflateException(childParser.getPositionDescription() +
675
                                ": No start tag found!");
676
                    }
678
                    final String childName = childParser.getName();
680
                    if (.equals(childName)) {
681
                        // Inflate all children.
682
                        rInflate(childParser, parent, childAttrs);
683
                    } else {
684
                        final View view = createViewFromTag(childName, childAttrs);
685
                        final ViewGroup group = (ViewGroup) parent;
687
                        // We try to load the layout params set in the <include /> tag. If
688
                        // they don't exist, we will rely on the layout params set in the
689
                        // included XML file.
690
                        // During a layoutparams generation, a runtime exception is thrown
691
                        // if either layout_width or layout_height is missing. We catch
692
                        // this exception and set localParams accordingly: true means we
693
                        // successfully loaded layout params from the <include /> tag,
694
                        // false means we need to rely on the included layout params.
695
                        ViewGroup.LayoutParams params = null;
696
                        try {
697
                            params = group.generateLayoutParams(attrs);
698
                        } catch (RuntimeException e) {
699
                            params = group.generateLayoutParams(childAttrs);
700
                        } finally {
701
                            if (params != null) {
702
                                view.setLayoutParams(params);
703
                            }
704
                        }
706
                        // Inflate all children.
707
                        rInflate(childParser, view, childAttrs);
709
                        // Attempt to override the included layout's android:id with the
710
                        // one set on the <include /> tag itself.
711
                        TypedArray a = .obtainStyledAttributes(attrs,
712
                            ....., 0, 0);
713
                        int id = a.getResourceId(....., .);
714
                        // While we're at it, let's try to override android:visibility.
715
                        int visibility = a.getInt(....., -1);
716
                        a.recycle();
718
                        if (id != .) {
719
                            view.setId(id);
720
                        }
722
                        switch (visibility) {
723
                            case 0:
724
                                view.setVisibility(.);
725
                                break;
726
                            case 1:
727
                                view.setVisibility(.);
728
                                break;
729
                            case 2:
730
                                view.setVisibility(.);
731
                                break;
732
                        }
734
                        group.addView(view);
735
                    }
736
                } finally {
737
                    childParser.close();
738
                }
739
            }
740
        } else {
741
            throw new InflateException("<include /> can only be used inside of a ViewGroup");
742
        }
744
        final int currentDepth = parser.getDepth();
745
        while (((type = parser.next()) != . ||
746
                parser.getDepth() > currentDepth) && type != .) {
747
            // Empty
748
        }
749
    }    
New to GrepCode? Check out our FAQ X