Board index » Android Tutorials with Source Code » Novice Tutorials

Skip to content

layoutinflater

Basic Tutorials concerning: GUI, Views, Activites, XML, Layouts, Intents, ...
Post a reply

layoutinflater

Postby yusuf » Wed Feb 24, 2010 10:57 pm

I have used layoutinflater and i want to intent another class onclick event of textview but it gives force to close error.



Maillist class

Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. package com.google;
  2.  
  3.  
  4.  
  5.  
  6.  
  7. import java.util.ArrayList;  
  8.  
  9. import java.util.List;  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. import com.google.ClickableListAdapter.ViewHolder;
  16.  
  17. import android.app.Dialog;
  18.  
  19. import android.app.ListActivity;  
  20.  
  21. import android.content.Context;  
  22.  
  23. import android.content.Intent;
  24.  
  25. import android.graphics.Bitmap;  
  26.  
  27. import android.graphics.BitmapFactory;  
  28.  
  29. import android.os.Bundle;  
  30.  
  31. import android.view.View;  
  32.  
  33. import android.widget.Button;
  34.  
  35. import android.widget.CheckBox;
  36.  
  37. import android.widget.ImageButton;
  38.  
  39. import android.widget.ImageView;  
  40.  
  41. import android.widget.TableRow;
  42.  
  43. import android.widget.TextView;  
  44.  
  45.  
  46.  
  47.  
  48.  
  49. /**
  50.  
  51.  * An example how to implement the ClickableListAdapter for a list view layout containing
  52.  
  53.  * a TextView and an ImageView.
  54.  
  55.  * @author poss3x
  56.  
  57.  */  
  58.  
  59. public class mailslist extends ListActivity {  
  60.  
  61.         Dialog dialog;// = new Dialog(this);
  62.  
  63.     /**
  64.  
  65.      * Our data class. This data will be bound to  
  66.  
  67.      * MyViewHolder, which in turn is used for the  
  68.  
  69.      * ListView.  
  70.  
  71.      */  
  72.  
  73.        
  74.  
  75.     static class MyData {  
  76.  
  77.         public MyData(String t,String t1,String t2, boolean e) {  
  78.  
  79.             text = t;
  80.  
  81.             text1 = t1;
  82.  
  83.             text2 = t2;
  84.  
  85.            
  86.  
  87.             enable = e;  
  88.  
  89.         }  
  90.  
  91.  
  92.  
  93.         String text,text1,text2;  
  94.  
  95.         Bitmap i1;
  96.  
  97.         boolean enable;  
  98.  
  99.     }  
  100.  
  101.      
  102.  
  103.     /**
  104.  
  105.      * Our very own holder referencing the view elements
  106.  
  107.      * of our ListView layout
  108.  
  109.      */  
  110.  
  111.     static class MyViewHolder extends ViewHolder {  
  112.  
  113.  
  114.  
  115.         public MyViewHolder(TextView t,TextView t1,TextView t2) {  
  116.  
  117.             sub = t;  
  118.  
  119.             from=t1;
  120.  
  121.             date=t2;
  122.  
  123.          
  124.  
  125.         }  
  126.  
  127.         TextView sub;  
  128.  
  129.        TextView from;
  130.  
  131.         TextView date;
  132.  
  133.     }  
  134.  
  135.  
  136.  
  137.     /**
  138.  
  139.      * The implementation of ClickableListAdapter
  140.  
  141.      */  
  142.  
  143.     private class MyClickableListAdapter extends ClickableListAdapter {  
  144.  
  145.  
  146.  
  147.         public MyClickableListAdapter(Context context, int viewid,  
  148.  
  149.                         List<MyData> objects) {  
  150.  
  151.             super(context, viewid, objects);  
  152.  
  153.             // nothing to do  
  154.  
  155.         }  
  156.  
  157.  
  158.  
  159.         protected void bindHolder(ViewHolder h) {  
  160.  
  161.             // Binding the holder keeps our data up to date.  
  162.  
  163.             // In contrast to createHolder this method is called for all items  
  164.  
  165.             // So, be aware when doing a lot of heavy stuff here.  
  166.  
  167.             // we simply transfer our object's data to the list item representatives  
  168.  
  169.             MyViewHolder mvh = (MyViewHolder) h;  
  170.  
  171.             MyData mo = (MyData)mvh.data;  
  172.  
  173.              
  174.  
  175.             mvh.sub.setText(mo.text);
  176.  
  177.             mvh.from.setText(mo.text1);
  178.  
  179.             mvh.date.setText(mo.text2);
  180.  
  181.  
  182.  
  183.         }  
  184.  
  185.  
  186.  
  187.         @Override  
  188.  
  189.         protected ViewHolder createHolder(View v) {  
  190.  
  191.             // createHolder will be called only as long, as the ListView is not filled  
  192.  
  193.             // entirely. That is, where we gain our performance:  
  194.  
  195.             // We use the relatively costly findViewById() methods and  
  196.  
  197.             // bind the view's reference to the holder objects.  
  198.  
  199.           /*  TextView text = (TextView) v.findViewById(R.id.text);  
  200.  
  201.            
  202.  
  203.             ImageButton button = (ImageButton) v.findViewById(R.id.Button);*/
  204.  
  205.                 TextView sub = (TextView) v.findViewById(R.id.lblSubject);
  206.  
  207.                 TextView from = (TextView) v.findViewById(R.id.lblfrom);
  208.  
  209.                 TextView date = (TextView) v.findViewById(R.id.lbldate);
  210.  
  211.                
  212.  
  213.                 ViewHolder mvh = new MyViewHolder(sub,from,date);  
  214.  
  215.  
  216.  
  217.             // Additionally, we make some icons clickable  
  218.  
  219.             // Mind, that item becomes clickable, when adding a click listener (see API)  
  220.  
  221.             // so, it is not necessary to use the android:clickable attribute in XML  
  222.  
  223.          
  224.  
  225.                
  226.  
  227.                 sub.setOnClickListener(new ClickableListAdapter.OnClickListener(mvh) {  
  228.  
  229.  
  230.  
  231.                 public void onClick(View v, ViewHolder viewHolder) {  
  232.  
  233.                     // we toggle the enabled state and also switch the icon  
  234.  
  235.         /*            MyViewHolder mvh = (MyViewHolder) viewHolder;  
  236.  
  237.                     MyData mo = (MyData) mvh.data;  
  238.  
  239.                     mo.enable = !mo.enable; // toggle  
  240.  
  241.                     ImageView icon = (ImageView) v;  
  242.  
  243.                     icon.setImageBitmap(  
  244.  
  245.                             mo.enable ? mailslist.this.mIconEnabled  
  246.  
  247.                                     : mailslist.this.mIconDisabled);*/
  248.  
  249.                        
  250.  
  251.          
  252.  
  253.                          
  254.  
  255.                     MyViewHolder mvh = (MyViewHolder) viewHolder;  
  256.  
  257.                     MyData mo = (MyData)mvh.data;  
  258.  
  259.                      
  260.  
  261.                     // we toggle an '*' in our text element  
  262.  
  263.                     String s = mo.text;  
  264.  
  265.                     if (s.charAt(0) == '*') {  
  266.  
  267.                         mo.text = s.substring(1);  
  268.  
  269.                     } else {  
  270.  
  271.                         mo.text = '*' + s;
  272.  
  273.                        
  274.  
  275.                         }  
  276.  
  277.                     mvh.sub.setText(mo.text);
  278.  
  279.                        
  280.  
  281.          //try onlick (intent) here
  282.  
  283.                 }  
  284.  
  285.                
  286.  
  287.             });
  288.  
  289.  
  290.  
  291.  
  292.  
  293.    
  294.  
  295.            
  296.  
  297.            
  298.  
  299.            
  300.  
  301.            
  302.  
  303.            
  304.  
  305.            
  306.  
  307.            
  308.  
  309.             // for text we implement a long click listener  
  310.  
  311.  
  312.  
  313.             sub.setOnLongClickListener(new ClickableListAdapter.OnLongClickListener(mvh) {  
  314.  
  315.                
  316.  
  317.                 @Override  
  318.  
  319.                 public void onLongClick(View v, ViewHolder viewHolder) {  
  320.  
  321.                          
  322.  
  323.                     MyViewHolder mvh = (MyViewHolder) viewHolder;  
  324.  
  325.                     MyData mo = (MyData)mvh.data;  
  326.  
  327.                      
  328.  
  329.                     // we toggle an '*' in our text element  
  330.  
  331.                     String s = mo.text;  
  332.  
  333.                     if (s.charAt(0) == '*') {  
  334.  
  335.                         mo.text = s.substring(1);  
  336.  
  337.                     } else {  
  338.  
  339.                         mo.text = '*' + s;
  340.  
  341.                        
  342.  
  343.                         }  
  344.  
  345.                     mvh.sub.setText(mo.text);  
  346.  
  347.                   /* dialog.setContentView(R.layout.contextdialog);
  348.  
  349.                     dialog.setTitle("Current Context");
  350.  
  351.                         dialog.show();*/
  352.  
  353.                    
  354.  
  355.                
  356.  
  357.  
  358.  
  359.                 }  
  360.  
  361.  
  362.  
  363.             });  
  364.  
  365.  
  366.  
  367.             return mvh; // finally, we return our new holder  
  368.  
  369.         }
  370.  
  371.  
  372.  
  373.                 protected void disp() {
  374.  
  375.                         // TODO Auto-generated method stub
  376.  
  377.                        
  378.  
  379.                 }
  380.  
  381.  
  382.  
  383.        
  384.  
  385.  
  386.  
  387.    
  388.  
  389.     }  
  390.  
  391.  
  392.  
  393.      
  394.  
  395.     @Override  
  396.  
  397.     public void onCreate(Bundle savedInstanceState) {  
  398.  
  399.         super.onCreate(savedInstanceState);  
  400.  
  401.  
  402.  
  403.      
  404.  
  405.        
  406.  
  407.         // fill list with some items...  
  408.  
  409.         // to demonstrate the performance we create a bunch of data objects  
  410.  
  411.        
  412.  
  413.         for (int i = 0; i < 10; ++i) {  
  414.  
  415.             //if ka logic laga na hai ider
  416.  
  417.                 //if(i%2) 24 feb(00 hrs)
  418.  
  419.                 mObjectList.add(new MyData("Subject" + i,"abc"+i+"@gmail.com", +i+" Days ago",true));
  420.  
  421.            
  422.  
  423.         }
  424.  
  425.      
  426.  
  427.         //here we set our adapter  
  428.  
  429.         setListAdapter(new MyClickableListAdapter(this,  
  430.  
  431.                 R.layout.maillist, mObjectList));  
  432.  
  433.  
  434.  
  435.    
  436.  
  437.     }  
  438.  
  439.  
  440.  
  441.     // --------------- field section -----------------  
  442.  
  443.     private Bitmap mIconEnabled;  
  444.  
  445.     private Bitmap mIconDisabled;  
  446.  
  447.    
  448.  
  449.      
  450.  
  451.   public List<MyData> mObjectList=new ArrayList<MyData>();
  452.  
  453. }  
Parsed in 0.055 seconds, using GeSHi 1.0.8.4




abstract class ClickableAdapter
Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1.  
  2. package com.google;
  3.  
  4.  
  5.  
  6. import java.util.ArrayList;
  7.  
  8. import java.util.List;
  9.  
  10.  
  11.  
  12. import android.content.Context;
  13.  
  14. import android.view.LayoutInflater;
  15.  
  16. import android.view.View;
  17.  
  18. import android.view.ViewGroup;
  19.  
  20. import android.widget.BaseAdapter;
  21.  
  22.  
  23.  
  24. public abstract class ClickableListAdapter extends BaseAdapter {  
  25.  
  26.     private LayoutInflater mInflater;  
  27.  
  28.     private List mDataObjects; // our generic object list  
  29.  
  30.     private int mViewId;  
  31.  
  32.  
  33.  
  34.     /**
  35.  
  36.      * This is the holder will provide fast access to arbitrary objects and
  37.  
  38.      * views. Use a subclass to adapt it for your personal needs.
  39.  
  40.      */  
  41.  
  42.     public static class ViewHolder {  
  43.  
  44.         // back reference to our list object  
  45.  
  46.         public Object data;
  47.  
  48.                 public Object icon;  
  49.  
  50.     }  
  51.  
  52.  
  53.  
  54.     /**
  55.  
  56.      * The click listener base class.
  57.  
  58.      */  
  59.  
  60.     public static abstract class OnClickListener implements  
  61.  
  62.             View.OnClickListener {  
  63.  
  64.  
  65.  
  66.         private ViewHolder mViewHolder;  
  67.  
  68.  
  69.  
  70.         /**
  71.  
  72.          * @param holder The holder of the clickable item
  73.  
  74.          */  
  75.  
  76.         public OnClickListener(ViewHolder holder) {  
  77.  
  78.             mViewHolder = holder;  
  79.  
  80.         }  
  81.  
  82.  
  83.  
  84.         // delegates the click event  
  85.  
  86.         public void onClick(View v) {  
  87.  
  88.             onClick(v, mViewHolder);  
  89.  
  90.         }  
  91.  
  92.  
  93.  
  94.         /**
  95.  
  96.          * Implement your click behavior here
  97.  
  98.          * @param v  The clicked view.
  99.  
  100.          */  
  101.  
  102.         public abstract void onClick(View v, ViewHolder viewHolder);  
  103.  
  104.     };  
  105.  
  106.  
  107.  
  108.     /**
  109.  
  110.      * The long click listener base class.
  111.  
  112.      */  
  113.  
  114.     public static abstract class OnLongClickListener implements  
  115.  
  116.             View.OnLongClickListener {  
  117.  
  118.         private ViewHolder mViewHolder;  
  119.  
  120.  
  121.  
  122.         /**
  123.  
  124.          * @param holder The holder of the clickable item
  125.  
  126.          */  
  127.  
  128.         public OnLongClickListener(ViewHolder holder) {  
  129.  
  130.             mViewHolder = holder;  
  131.  
  132.         }  
  133.  
  134.  
  135.  
  136.         // delegates the click event  
  137.  
  138.         public boolean onLongClick(View v) {  
  139.  
  140.             onLongClick(v, mViewHolder);  
  141.  
  142.             return true;  
  143.  
  144.         }  
  145.  
  146.  
  147.  
  148.         /**
  149.  
  150.          * Implement your click behavior here
  151.  
  152.          * @param v  The clicked view.
  153.  
  154.          */  
  155.  
  156.         public abstract void onLongClick(View v, ViewHolder viewHolder);  
  157.  
  158.  
  159.  
  160.     };  
  161.  
  162.  
  163.  
  164.     /**
  165.  
  166.      * @param context The current context
  167.  
  168.      * @param viewid The resource id of your list view item
  169.  
  170.      * @param objects The object list, or null, if you like to indicate an empty
  171.  
  172.      * list
  173.  
  174.      */  
  175.  
  176.     public ClickableListAdapter(Context context, int viewid, List objects) {  
  177.  
  178.  
  179.  
  180.         // Cache the LayoutInflate to avoid asking for a new one each time.  
  181.  
  182.         mInflater = LayoutInflater.from(context);  
  183.  
  184.         mDataObjects = objects;  
  185.  
  186.         mViewId = viewid;  
  187.  
  188.  
  189.  
  190.         if (objects == null) {  
  191.  
  192.             mDataObjects = new ArrayList<Object>();  
  193.  
  194.         }  
  195.  
  196.     }  
  197.  
  198.  
  199.  
  200.     /**
  201.  
  202.      * The number of objects in the list.
  203.  
  204.      */  
  205.  
  206.     public int getCount() {  
  207.  
  208.         return mDataObjects.size();  
  209.  
  210.     }  
  211.  
  212.  
  213.  
  214.     /**
  215.  
  216.      * @return We simply return the object at position of our object list Note,
  217.  
  218.      *         the holder object uses a back reference to its related data
  219.  
  220.      *         object. So, the user usually should use {@link ViewHolder#data}
  221.  
  222.      *         for faster access.
  223.  
  224.      */  
  225.  
  226.     public Object getItem(int position) {  
  227.  
  228.         return mDataObjects.get(position);  
  229.  
  230.     }  
  231.  
  232.  
  233.  
  234.     /**
  235.  
  236.      * We use the array index as a unique id. That is, position equals id.
  237.  
  238.      *  
  239.  
  240.      * @return The id of the object
  241.  
  242.      */  
  243.  
  244.     public long getItemId(int position) {  
  245.  
  246.         return position;  
  247.  
  248.     }  
  249.  
  250.  
  251.  
  252.     /**
  253.  
  254.      * Make a view to hold each row. This method is instantiated for each list
  255.  
  256.      * object. Using the Holder Pattern, avoids the unnecessary
  257.  
  258.      * findViewById()-calls.
  259.  
  260.      */  
  261.  
  262.     public View getView(int position, View view, ViewGroup parent) {  
  263.  
  264.         // A ViewHolder keeps references to children views to avoid uneccessary  
  265.  
  266.         // calls  
  267.  
  268.         // to findViewById() on each row.  
  269.  
  270.         ViewHolder holder;  
  271.  
  272.  
  273.  
  274.         // When view is not null, we can reuse it directly, there is no need  
  275.  
  276.         // to reinflate it. We only inflate a new View when the view supplied  
  277.  
  278.         // by ListView is null.  
  279.  
  280.         if (view == null) {  
  281.  
  282.  
  283.  
  284.             view = mInflater.inflate(mViewId, null);  
  285.  
  286.             // call the user's implementation  
  287.  
  288.             holder = createHolder(view);  
  289.  
  290.             // we set the holder as tag  
  291.  
  292.             view.setTag(holder);  
  293.  
  294.  
  295.  
  296.         } else {  
  297.  
  298.             // get holder back...much faster than inflate  
  299.  
  300.             holder = (ViewHolder) view.getTag();  
  301.  
  302.         }  
  303.  
  304.  
  305.  
  306.         // we must update the object's reference  
  307.  
  308.         holder.data = getItem(position);  
  309.  
  310.         // call the user's implementation  
  311.  
  312.         bindHolder(holder);  
  313.  
  314.  
  315.  
  316.         return view;  
  317.  
  318.     }  
  319.  
  320.  
  321.  
  322.     /**
  323.  
  324.      * Creates your custom holder, that carries reference for e.g. ImageView
  325.  
  326.      * and/or TextView. If necessary connect your clickable View object with the
  327.  
  328.      * PrivateOnClickListener, or PrivateOnLongClickListener
  329.  
  330.      *  
  331.  
  332.      * @param vThe view for the new holder object
  333.  
  334.      */  
  335.  
  336.     protected abstract ViewHolder createHolder(View v);  
  337.  
  338.  
  339.  
  340.     /**
  341.  
  342.      * Binds the data from user's object to the holder
  343.  
  344.      * @param h  The holder that shall represent the data object.
  345.  
  346.      */  
  347.  
  348.     protected abstract void bindHolder(ViewHolder h);  
  349.  
  350. }  
  351.  
  352.  
  353.  
  354.  
Parsed in 0.047 seconds, using GeSHi 1.0.8.4


These are my classes plz tell me how to intent another class on "onClick" event.
Androiding.........................
yusuf
Experienced Developer
Experienced Developer
 
Posts: 57
Joined: Mon Feb 15, 2010 4:25 pm
Location: Pune,India
Top
Top
Post a reply

Return to Novice Tutorials

Who is online

Users browsing this forum: No registered users and 6 guests

Board index The team • Delete all board cookies • All times are UTC + 1 hour