我创建为Android应用程序，首先我用一个库项目，包括在应用面板的功能，它能正常工作。后来我发现，我的.apk文件，包括我未使用的图像和库项目，这增加了我的应用程序的大小的XML文件，所以我决定实现我自己的面板功能。当我跑的应用程序进行更改，我得到的错误 09-28 00后：01：00.639：E / AndroidRuntime（1462）：致命异常：主要 09-28 00：01：00.639：E / AndroidRuntime（1462）：java.lang.RuntimeException的：无法启动的活动ComponentInfo {com.widgets.application / com.widgets.application.MainActivity}：android.view.InflateException：二进制XML文件行＃14：错误充气类com.widgets.application.utils.Panel

我在这里上传我的项目，请帮我摆脱这个问题

http://www.mediafire.com/?m10u0y5cenqnb1u

日志猫如下

  09-28 00：01：00.639：E / AndroidRuntime（1462）：致命异常：主要
09-28 00：01：00.639：E / AndroidRuntime（1462）：java.lang.RuntimeException的：无法启动的活动ComponentInfo {com.widgets.application / com.widgets.application.MainActivity}：android.view.InflateException：二进制XML文件行＃14：错误充气类com.widgets.application.utils.Panel
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.ActivityThread.performLaunchActivity（ActivityThread.java:1647）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.ActivityThread.handleLaunchActivity（ActivityThread.java:1663）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.ActivityThread.access $ 1500（ActivityThread.java:117）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.ActivityThread $ H.handleMessage（ActivityThread.java:931）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.os.Handler.dispatchMessage（Handler.java:99）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.os.Looper.loop（Looper.java:123）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.ActivityThread.main（ActivityThread.java:3683）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在java.lang.reflect.Method.invokeNative（本机方法）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在java.lang.reflect.Method.invoke（Method.java:507）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在com.android.internal.os.ZygoteInit $ MethodAndArgsCaller.run（ZygoteInit.java:839）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在com.android.internal.os.ZygoteInit.main（ZygoteInit.java:597）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在dalvik.system.NativeStart.main（本机方法）
09-28 00：01：00.639：E / AndroidRuntime（1462）：android.view.InflateException：二进制XML文件中的行＃14：错误充气类com.widgets.application.utils.Panel所致
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.createView（LayoutInflater.java:518）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.createViewFromTag（LayoutInflater.java:570）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.rInflate（LayoutInflater.java:623）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.rInflate（LayoutInflater.java:626）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.inflate（LayoutInflater.java:408）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.inflate（LayoutInflater.java:320）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.inflate（LayoutInflater.java:276）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在com.android.internal.policy.impl.PhoneWindow.setContentView（PhoneWindow.java:207）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.Activity.setContentView（Activity.java:1657）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在com.widgets.application.MainActivity.onCreate（MainActivity.java:65）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.Instrumentation.callActivityOnCreate（Instrumentation.java:1047）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.app.ActivityThread.performLaunchActivity（ActivityThread.java:1611）
09-28 00：01：00.639：E / AndroidRuntime（1462）：11 ...更多
09-28 00：01：00.639：E / AndroidRuntime（1462）：由：java.lang.reflect.InvocationTargetException
09-28 00：01：00.639：E / AndroidRuntime（1462）：在java.lang.reflect.Constructor.constructNative（本机方法）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在java.lang.reflect.Constructor.newInstance（Constructor.java:415）
09-28 00：01：00.639：E / AndroidRuntime（1462）：在android.view.LayoutInflater.createView（LayoutInflater.java:505）
09-28 00：01：00.639：E / AndroidRuntime（1462）：22 ...更多
09-28 00：01：00.639：E / AndroidRuntime（1462）：java.lang.IllegalArgumentException异常：二进制XML文件中的行＃14：内容属性是必需的，且必须指向一个有效的小孩所致。
09-28 00：01：00.639：E / AndroidRuntime（1462）：在com.widgets.application.utils.Panel＆LT; INIT＆GT;（Panel.java:116）
09-28 00：01：00.639：E / AndroidRuntime（1462）：25 ...更多
 

编辑：Panel.java

 公共类面板扩展的LinearLayout {

私有静态最后字符串变量=面板;

/ **
 *面板打开时回调调用/关闭。
 * /
公共静态接口OnPanelListener {
    / **
     *当面板变得完全关闭时调用。
     * /
    公共无效onPanelClosed（面板面板）;

    / **
     *调用当面板变成完全打开。
     * /
    公共无效onPanelOpened（面板面板）;
}

私人布尔mIsShrinking;
私人诠释mPosition;
私人诠释MDURATION;
私人布尔mLinearFlying;
私人诠释mHandleId;
私人诠释mContentId;
私人查看mHandle;
私人查看mContent;
私人绘制对象mOpenedHandle;
私人绘制对象mClosedHandle;
私人浮动mTrackX;
私人浮动mTrackY;
私人浮动mVelocity;

私人OnPanelListener panelListener;

公共静态最终诠释TOP = 0;
公共静态最终诠释BOTTOM = 1;
公共静态最终诠释LEFT = 2;
公共静态最终诠释RIGHT = 3;

私人枚举国家{
    ABOUT_TO_ANIMATE，动画，准备好了，跟踪，飞行，
};

私有状态mState;
私人插补mInterpolator;
私人GestureDetector mGestureDetector;
私人诠释mContentHeight;
私人诠释mContentWidth;
私人诠释mOrientation;
私人浮动mWeight;
私人PanelOnGestureListener mGestureListener;
私人布尔mBringToFront;

公共面板（上下文的背景下，ATTRS的AttributeSet）{
    超（背景下，ATTRS）;
    TypedArray A = context.obtainStyledAttributes（ATTRS，R.styleable.Panel）;
    MDURATION = a.getInteger（R.styleable.Panel_animationDuration，750）; //时间
                                                                        //默认
                                                                        // 至
                                                                        // 750
                                                                        // 女士
    mPosition = a.getInteger（R.styleable.Panel_position，底部）; // 位置
                                                                    //默认
                                                                    // 至
                                                                    // 底部
    mLinearFlying = a.getBoolean（R.styleable.Panel_linearFlying，假）; // linearFlying
                                                                            //默认
                                                                            // 至
                                                                            // 假
    mWeight = a.getFraction（R.styleable.Panel_weight，0,1，0.0）; // 重量
                                                                    //默认
                                                                    // 至
                                                                    // 0.0
    如果（mWeight℃，|| mWeight→1）{
        mWeight = 0.0;
        Log.w（TAG，a.getPositionDescription（）
                +：重量必须大于0和＆lt; = 1）;
    }
    mOpenedHandle = a.getDrawable（R.styleable.Panel_openedHandle）;
    mClosedHandle = a.getDrawable（R.styleable.Panel_closedHandle）;

    RuntimeException的E = NULL;
    mHandleId = a.getResourceId（R.styleable.Panel_handle，0）;
    如果（mHandleId == 0）{
        E =新抛出：IllegalArgumentException（
                a.getPositionDescription（）
                        +：把手属性是必需的，且必须指向一个有效的小孩）;
    }
    mContentId = a.getResourceId（R.styleable.Panel_content，0）;
    如果（mContentId == 0）{
        E =新抛出：IllegalArgumentException（
                a.getPositionDescription（）
                        +：内容属性是必需的，且必须指向一个有效的小孩）;
    }
    a.recycle（）;

    如果（E！= NULL）{
        扔ê;
    }
    mOrientation =（mPosition == TOP || mPosition ==底部）？垂直
            ：水平;
    setOrientation（mOrientation）;
    mState = State.READY;
    mGestureListener =新PanelOnGestureListener（）;
    mGestureDetector =新GestureDetector（mGestureListener）;
    mGestureDetector.setIsLong pressEnabled（假）;

    //我真的不知道为什么我需要这个...
    setBaselineAligned（假）;
}

/ **
 *设置接收通知时，面板将成为听众
 * 开关。
 *
 * @参数onPanelListener
 *面板打开时被通知的监听器/关闭。
 * /
公共无效setOnPanelListener（OnPanelListener onPanelListener）{
    panelListener = onPanelListener;
}

/ **
 *获取面板的mHandle
 *
 返回：小组mHandle
 * /
公共查看getHandle（）{
    返回mHandle;
}

/ **
 *获取面板的mContent
 *
 返回：小组mContent
 * /
公共景观的getContent（）{
    返回mContent;
}

/ **
 *设置面板动画的加速曲线。
 *
 * @参数我
 *定义加速度曲线插补
 * /
公共无效setInterpolator（插补我）{
    mInterpolator =我;
}

/ **
 *设置面板的打开状态。
 *
 * @参数开
 *如果真面板是要打开，否则为false小组将关闭。
 * @参数动画
 *如果真用动画，否则为false。
 *
 返回：如果真进行操作，否则为false。
 *
 * /
公共布尔就是setOpen（布尔开放，布尔动画）{
    如果（mState == State.READY和放大器;＆安培; isOpen（）函数^开）{
        mIsShrinking =开启！;
        如果（动画）{
            mState = State.ABOUT_TO_ANIMATE;
            如果（！mIsShrinking）{
                //这样可以使闪烁现象，所以我们在测试mState
                // dispatchDraw（）
                //看看是否等于ABOUT_TO_ANIMATE
                mContent.setVisibility（可见）;
            }
            后期（startAnimation）;
        } 其他 {
            mContent.setVisibility（打开可见：那么哪去了？）;
            后期处理（）;
        }
        返回true;
    }
    返回false;
}

/ **
 *返回面板打开的状态。
 *
 返回：真如果面板被打开，否则为false。
 * /
公共布尔isOpen（）函数{
    返回mContent.getVisibility（）==可见;
}

@覆盖
保护无效onFinishInflate（）{
    super.onFinishInflate（）;
    mHandle = findViewById（mHandleId）;
    如果（mHandle == NULL）{
        字符串名称= getResources（）getResourceEntryName（mHandleId）。
        抛出新的RuntimeException（
                你的小组必须有一个孩子查看其id属性是'R.id.
                        +姓名+'）;
    }
    mHandle.setOnTouchListener（touchListener）;
    mHandle.setOnClickListener（clickListener）;

    mContent = findViewById（mContentId）;
    如果（mContent == NULL）{
        字符串名称= getResources（）getResourceEntryName（mHandleId）。
        抛出新的RuntimeException（
                你的小组必须有一个孩子查看其id属性是'R.id.
                        +姓名+'）;
    }

    //重新定位儿童
    removeView（mHandle）;
    removeView（mContent）;
    如果（mPosition == TOP || mPosition ==左）{
        addView（mContent）;
        addView（mHandle）;
    } 其他 {
        addView（mHandle）;
        addView（mContent）;
    }

    如果（mClosedHandle！= NULL）{
        mHandle.setBackgroundDrawable（mClosedHandle）;
    }
    mContent.setClickable（真正的）;
    mContent.setVisibility（GONE）;
    如果（mWeight大于0）{
        ViewGroup.LayoutParams PARAMS = mContent.getLayoutParams（）;
        如果（mOrientation ==垂直）{
            params.height = ViewGroup.LayoutParams.FILL_PARENT;
        } 其他 {
            params.width = ViewGroup.LayoutParams.FILL_PARENT;
        }
        mContent.setLayoutParams（PARAMS）;
    }
}

@覆盖
保护无效onAttachedToWindow（）{
    super.onAttachedToWindow（）;
    ViewParent父=的getParent（）;
    如果（家长= NULL和放大器;！＆安培;父母的instanceof的FrameLayout）{
        mBringToFront =真;
    }
}

@覆盖
保护无效onMeasure（INT widthMeasureSpec，诠释heightMeasureSpec）{
    如果（mWeight大于0＆安培;＆安培; mContent.getVisibility（）==可见）{
        查看父=（查看）的getParent（）;
        如果（父！= NULL）{
            如果（mOrientation ==垂直）{
                heightMeasureSpec = MeasureSpec.makeMeasureSpec（
                        （中间体）（parent.getHeight（）* mWeight），
                        MeasureSpec.EXACTLY）;
            } 其他 {
                widthMeasureSpec = MeasureSpec.makeMeasureSpec（
                        （中间体）（parent.getWidth（）* mWeight），
                        MeasureSpec.EXACTLY）;
            }
        }
    }
    super.onMeasure（widthMeasureSpec，heightMeasureSpec）;
}

@覆盖
保护无效onLayout（布尔改变，诠释L，INT T，INT R，int b）在{
    super.onLayout（改变，L，T，R，B）;
    mContentWidth = mContent.getWidth（）;
    mContentHeight = mContent.getHeight（）;
}

@覆盖
保护无效dispatchDraw（帆布油画）{
    //字符串名称= getResources（）getResourceEntryName（的getId（））。
    // Log.d（TAG，名+ispatchDraw+ mState）;
    //这就是为什么'mState'加入：
    //避免动画开始前闪烁
    如果（mState == State.ABOUT_TO_ANIMATE和放大器;＆安培;！mIsShrinking）{
        INT三角洲= mOrientation ==垂直？ mContentHeight
                ：mContentWidth;
        如果（mPosition ==左|| mPosition == TOP）{
            三角洲= -delta;
        }
        如果（mOrientation ==垂直）{
            canvas.translate（0，增量）;
        } 其他 {
            canvas.translate（增量，0）;
        }
    }
    如果（mState == State.TRACKING || mState == State.FLYING）{
        canvas.translate（mTrackX，mTrackY）;
    }
    super.dispatchDraw（画布）;
}

私人浮动ensureRange（浮动V，INT分钟，INT最大）{
    ν= Math.max（ⅴ，分钟）;
    ν= Math.min（ⅴ，最大值）;
    返回伏;
}

OnTouchListener touchListener =新OnTouchListener（）{
    INT INITX;
    INT inity这;
    布尔setInitialPosition;

    公共布尔onTouch（视图V，MotionEvent事件）{
        如果（mState == State.ANIMATING）{
            //我们动画
            返回false;
        }
        // Log.d（TAG，状态：+ mState +X：+ event.getX（）+Y+
        // event.getY（））;
        INT行动= event.getAction（）;
        如果（动作== MotionEvent.ACTION_DOWN）{
            如果（mBringToFront）{
                bringToFront（）;
            }
            INITX = 0;
            inity这= 0;
            如果（mContent.getVisibility（）==消失）{
                //因为我们可能不知道的内容方面，我们使用的因素
                // 这里
                如果（mOrientation ==垂直）{
                    inity这= mPosition == TOP？ -1：1;
                } 其他 {
                    INITX = mPosition ==剩下什么？ -1：1;
                }
            }
            setInitialPosition = TRUE;
        } 其他 {
            如果（setInitialPosition）{
                //现在我们知道的内容方面，所以我们乘的因素...
                INITX * = mContentWidth;
                inity这* = mContentHeight;
                // ...并设置初始面板上的位置
                mGestureListener.setScroll（INITX，inity这）;
                setInitialPosition = FALSE;
                //为offsetLocation我们有反转的值
                INITX = -initX;
                inity这= -initY;
            }
            //偏移每ACTION_MOVE和放大器; ACTION_UP事件
            event.offsetLocation（INITX，inity这）;
        }
        如果（！mGestureDetector.onTouchEvent（事件））{
            如果（动作== MotionEvent.ACTION_UP）{
                //滚动后TUP了
                后期（startAnimation）;
            }
        }
        返回false;
    }
};

OnClickListener clickListener =新OnClickListener（）{
    公共无效的onClick（视图v）{
        如果（mBringToFront）{
            bringToFront（）;
        }
        如果（initChange（））{
            后期（startAnimation）;
        }
    }
};

公共布尔initChange（）{
    如果（mState！= State.READY）{
        //我们的动画或只是以动画
        返回false;
    }
    mState = State.ABOUT_TO_ANIMATE;
    mIsShrinking = mContent.getVisibility（）==可见;
    如果（！mIsShrinking）{
        //这样可以使闪烁现象，所以我们测试mState在dispatchDraw（）
        //看看是否等于ABOUT_TO_ANIMATE
        mContent.setVisibility（可见）;
    }
    返回true;
}

可运行startAnimation =新的Runnable（）{
    公共无效的run（）{
        //这就是为什么我们发布此Runnable的情侣上述各行的：
        //现在它保存到使用mContent.getHeight（）及和放大器; mContent.getWidth（）
        TranslateAnimation动画;
        INT fromXDelta = 0，toXDelta = 0，fromYDelta = 0，toYDelta = 0;
        如果（mState == State.FLYING）{
            mIsShrinking =（mPosition == TOP || mPosition == LEFT）
                    ^（mVelocity大于0）;
        }
        INT calculatedDuration;
        如果（mOrientation ==垂直）{
            INT高= mContentHeight;
            如果（！mIsShrinking）{
                fromYDelta = mPosition == TOP？ -height：高度;
            } 其他 {
                toYDelta = mPosition == TOP？ -height：高度;
            }
            如果（mState == State.TRACKING）{
                如果（Math.abs（mTrackY  -  fromYDelta）＆LT; Math.abs（mTrackY
                         -  toYDelta））{
                    mIsShrinking = mIsShrinking！;
                    toYDelta = fromYDelta;
                }
                fromYDelta =（INT）mTrackY;
            }否则，如果（mState == State.FLYING）{
                fromYDelta =（INT）mTrackY;
            }
            //飞行事件，我们计算的动画时间根据
            //飞行速度
            //也是非常高的速度，确保持续时间GT = 20毫秒
            如果（mState == State.FLYING和放大器;＆安培; mLinearFlying）{
                calculatedDuration =（INT）（1000 *数学
                        。ABS（（toYDelta  -  fromYDelta）/ mVelocity））;
                calculatedDuration = Math.max（calculatedDuration，20）;
            } 其他 {
                calculatedDuration = MDURATION
                        * Math.abs（toYDelta  -  fromYDelta）/ mContentHeight;
            }
        } 其他 {
            INT宽度= mContentWidth;
            如果（！mIsShrinking）{
                fromXDelta = mPosition ==剩下什么？ - 宽度：宽度;
            } 其他 {
                toXDelta = mPosition ==剩下什么？ - 宽度：宽度;
            }
            如果（mState == State.TRACKING）{
                如果（Math.abs（mTrackX  -  fromXDelta）＆LT; Math.abs（mTrackX
                         -  toXDelta））{
                    mIsShrinking = mIsShrinking！;
                    toXDelta = fromXDelta;
                }
                fromXDelta =（INT）mTrackX;
            }否则，如果（mState == State.FLYING）{
                fromXDelta =（INT）mTrackX;
            }
            //飞行事件，我们计算的动画时间根据
            //飞行速度
            //也是非常高的速度，确保持续时间GT = 20毫秒
            如果（mState == State.FLYING和放大器;＆安培; mLinearFlying）{
                calculatedDuration =（INT）（1000 *数学
                        。ABS（（toXDelta  -  fromXDelta）/ mVelocity））;
                calculatedDuration = Math.max（calculatedDuration，20）;
            } 其他 {
                calculatedDuration = MDURATION
                        * Math.abs（toXDelta  -  fromXDelta）/ mContentWidth;
            }
        }

        mTrackX = mTrackY = 0;
        如果（calculatedDuration == 0）{
            mState = State.READY;
            如果（mIsShrinking）{
                mContent.setVisibility（GONE）;
            }
            后期处理（）;
            返回;
        }

        动画=新TranslateAnimation（fromXDelta，toXDelta，
                fromYDelta，toYDelta）;
        animation.setDuration（calculatedDuration）;
        animation.setAnimationListener（animationListener）;
        如果（mState == State.FLYING和放大器;＆安培; mLinearFlying）{
            animation.setInterpolator（新LinearInterpolator（））;
        }否则，如果（mInterpolator！​​= NULL）{
            animation.setInterpolator（mInterpolator）;
        }
        startAnimation（动画）;
    }
};

私人AnimationListener animationListener =新AnimationListener（）{
    公共无效onAnimationEnd（动画动画）{
        mState = State.READY;
        如果（mIsShrinking）{
            mContent.setVisibility（GONE）;
        }
        后期处理（）;
    }

    公共无效onAnimationRepeat（动画动画）{
    }

    公共无效onAnimationStart（动画动画）{
        mState = State.ANIMATING;
    }
};

私人无效后处理（）{
    如果（mIsShrinking＆安培;＆安培;！mClosedHandle = NULL）{
        mHandle.setBackgroundDrawable（mClosedHandle）;
    }否则如果（mIsShrinking＆安培;！＆安培;！mOpenedHandle = NULL）{
        mHandle.setBackgroundDrawable（mOpenedHandle）;
    }
    //调用监听器（如果有）
    如果（panelListener！= NULL）{
        如果（mIsShrinking）{
            panelListener.onPanelClosed（Panel.this）;
        } 其他 {
            panelListener.onPanelOpened（Panel.this）;
        }
    }
}

类PanelOnGestureListener实现OnGestureListener {
    浮动scrollY;
    浮动scrollX;

    公共无效setScroll（INT initScrollX，诠释initScrollY）{
        scrollX = initScrollX;
        scrollY = initScrollY;
    }

    公共布尔onDown（MotionEvent E）{
        scrollX = scrollY = 0;
        initChange（）;
        返回true;
    }

    公共布尔onFling（MotionEvent E1，E2 MotionEvent，浮velocityX，
            浮动velocityY）{
        mState = State.FLYING;
        mVelocity = mOrientation ==垂直？ velocityY：velocityX;
        后期（startAnimation）;
        返回true;
    }

    公共无效onLong preSS（MotionEvent E）{
        // 不曾用过
    }

    公共布尔onScroll（MotionEvent E1，E2 MotionEvent，
            浮distanceX，浮distanceY）{
        mState = State.TRACKING;
        浮tmpY = 0，tmpX = 0;
        如果（mOrientation ==垂直）{
            scrollY  -  = distanceY;
            如果（mPosition == TOP）{
                tmpY = ensureRange（scrollY，-mContentHeight，0）;
            } 其他 {
                tmpY = ensureRange（scrollY，0，mContentHeight）;
            }
        } 其他 {
            scrollX  -  = distanceX;
            如果（mPosition ==左）{
                tmpX = ensureRange（scrollX，-mContentWidth，0）;
            } 其他 {
                tmpX = ensureRange（scrollX，0，mContentWidth）;
            }
        }
        如果（tmpX！= mTrackX || tmpY！= mTrackY）{
            mTrackX = tmpX;
            mTrackY = tmpY;
            无效（）;
        }
        返回true;
    }

    公共无效OnShow中preSS（MotionEvent E）{
        // 不曾用过
    }

    公共布尔onSingleTapUp（MotionEvent E）{
        // 不曾用过
        返回false;
    }
}

}
 

解决方案

配置它最后。只有一行的code被搞乱了整个应用程序。只是改变了该行和应用程序启动和运行。发布的解决方案，因此它可以帮助别人的未来。这条线应该在布局文件进行更改

的xmlns：面板=htt​​p://schemas.android.com/apk/res-auto

I am creating an application for android, at first i used one library project to include Panel functionality in the application and it worked fine. Later i found that my .apk file included my unused images and xml file of library project which increased the size of my application, so i decided to implement the panel functionality on my own. When i ran the application after making the changes i am getting the error 09-28 00:01:00.639: E/AndroidRuntime(1462): FATAL EXCEPTION: main 09-28 00:01:00.639: E/AndroidRuntime(1462): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.widgets.application/com.widgets.application.MainActivity}: android.view.InflateException: Binary XML file line #14: Error inflating class com.widgets.application.utils.Panel

I am uploading my project here, please help me get rid of this problem

http://www.mediafire.com/?m10u0y5cenqnb1u

The log cat is as below

09-28 00:01:00.639: E/AndroidRuntime(1462): FATAL EXCEPTION: main
09-28 00:01:00.639: E/AndroidRuntime(1462): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.widgets.application/com.widgets.application.MainActivity}: android.view.InflateException: Binary XML file line #14: Error inflating class com.widgets.application.utils.Panel
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1647)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:1663)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.ActivityThread.access$1500(ActivityThread.java:117)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:931)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.os.Handler.dispatchMessage(Handler.java:99)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.os.Looper.loop(Looper.java:123)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.ActivityThread.main(ActivityThread.java:3683)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at java.lang.reflect.Method.invokeNative(Native Method)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at java.lang.reflect.Method.invoke(Method.java:507)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:839)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:597)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at dalvik.system.NativeStart.main(Native Method)
09-28 00:01:00.639: E/AndroidRuntime(1462): Caused by: android.view.InflateException: Binary XML file line #14: Error inflating class com.widgets.application.utils.Panel
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.createView(LayoutInflater.java:518)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.createViewFromTag(LayoutInflater.java:570)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.rInflate(LayoutInflater.java:623)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.rInflate(LayoutInflater.java:626)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.inflate(LayoutInflater.java:408)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.inflate(LayoutInflater.java:320)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.inflate(LayoutInflater.java:276)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at com.android.internal.policy.impl.PhoneWindow.setContentView(PhoneWindow.java:207)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.Activity.setContentView(Activity.java:1657)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at com.widgets.application.MainActivity.onCreate(MainActivity.java:65)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1047)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1611)
09-28 00:01:00.639: E/AndroidRuntime(1462):     ... 11 more
09-28 00:01:00.639: E/AndroidRuntime(1462): Caused by: java.lang.reflect.InvocationTargetException
09-28 00:01:00.639: E/AndroidRuntime(1462):     at java.lang.reflect.Constructor.constructNative(Native Method)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at java.lang.reflect.Constructor.newInstance(Constructor.java:415)
09-28 00:01:00.639: E/AndroidRuntime(1462):     at android.view.LayoutInflater.createView(LayoutInflater.java:505)
09-28 00:01:00.639: E/AndroidRuntime(1462):     ... 22 more
09-28 00:01:00.639: E/AndroidRuntime(1462): Caused by: java.lang.IllegalArgumentException: Binary XML file line #14: The content attribute is required and must refer to a valid child.
09-28 00:01:00.639: E/AndroidRuntime(1462):     at com.widgets.application.utils.Panel.<init>(Panel.java:116)
09-28 00:01:00.639: E/AndroidRuntime(1462):     ... 25 more

EDIT: Panel.java;

public class Panel extends LinearLayout {

private static final String TAG = "Panel";

/**
 * Callback invoked when the panel is opened/closed.
 */
public static interface OnPanelListener {
    /**
     * Invoked when the panel becomes fully closed.
     */
    public void onPanelClosed(Panel panel);

    /**
     * Invoked when the panel becomes fully opened.
     */
    public void onPanelOpened(Panel panel);
}

private boolean mIsShrinking;
private int mPosition;
private int mDuration;
private boolean mLinearFlying;
private int mHandleId;
private int mContentId;
private View mHandle;
private View mContent;
private Drawable mOpenedHandle;
private Drawable mClosedHandle;
private float mTrackX;
private float mTrackY;
private float mVelocity;

private OnPanelListener panelListener;

public static final int TOP = 0;
public static final int BOTTOM = 1;
public static final int LEFT = 2;
public static final int RIGHT = 3;

private enum State {
    ABOUT_TO_ANIMATE, ANIMATING, READY, TRACKING, FLYING,
};

private State mState;
private Interpolator mInterpolator;
private GestureDetector mGestureDetector;
private int mContentHeight;
private int mContentWidth;
private int mOrientation;
private float mWeight;
private PanelOnGestureListener mGestureListener;
private boolean mBringToFront;

public Panel(Context context, AttributeSet attrs) {
    super(context, attrs);
    TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.Panel);
    mDuration = a.getInteger(R.styleable.Panel_animationDuration, 750); // duration
                                                                        // defaults
                                                                        // to
                                                                        // 750
                                                                        // ms
    mPosition = a.getInteger(R.styleable.Panel_position, BOTTOM); // position
                                                                    // defaults
                                                                    // to
                                                                    // BOTTOM
    mLinearFlying = a.getBoolean(R.styleable.Panel_linearFlying, false); // linearFlying
                                                                            // defaults
                                                                            // to
                                                                            // false
    mWeight = a.getFraction(R.styleable.Panel_weight, 0, 1, 0.0f); // weight
                                                                    // defaults
                                                                    // to
                                                                    // 0.0
    if (mWeight < 0 || mWeight > 1) {
        mWeight = 0.0f;
        Log.w(TAG, a.getPositionDescription()
                + ": weight must be > 0 and <= 1");
    }
    mOpenedHandle = a.getDrawable(R.styleable.Panel_openedHandle);
    mClosedHandle = a.getDrawable(R.styleable.Panel_closedHandle);

    RuntimeException e = null;
    mHandleId = a.getResourceId(R.styleable.Panel_handle, 0);
    if (mHandleId == 0) {
        e = new IllegalArgumentException(
                a.getPositionDescription()
                        + ": The handle attribute is required and must refer to a valid child.");
    }
    mContentId = a.getResourceId(R.styleable.Panel_content, 0);
    if (mContentId == 0) {
        e = new IllegalArgumentException(
                a.getPositionDescription()
                        + ": The content attribute is required and must refer to a valid child.");
    }
    a.recycle();

    if (e != null) {
        throw e;
    }
    mOrientation = (mPosition == TOP || mPosition == BOTTOM) ? VERTICAL
            : HORIZONTAL;
    setOrientation(mOrientation);
    mState = State.READY;
    mGestureListener = new PanelOnGestureListener();
    mGestureDetector = new GestureDetector(mGestureListener);
    mGestureDetector.setIsLongpressEnabled(false);

    // i DON'T really know why i need this...
    setBaselineAligned(false);
}

/**
 * Sets the listener that receives a notification when the panel becomes
 * open/close.
 * 
 * @param onPanelListener
 *            The listener to be notified when the panel is opened/closed.
 */
public void setOnPanelListener(OnPanelListener onPanelListener) {
    panelListener = onPanelListener;
}

/**
 * Gets Panel's mHandle
 * 
 * @return Panel's mHandle
 */
public View getHandle() {
    return mHandle;
}

/**
 * Gets Panel's mContent
 * 
 * @return Panel's mContent
 */
public View getContent() {
    return mContent;
}

/**
 * Sets the acceleration curve for panel's animation.
 * 
 * @param i
 *            The interpolator which defines the acceleration curve
 */
public void setInterpolator(Interpolator i) {
    mInterpolator = i;
}

/**
 * Set the opened state of Panel.
 * 
 * @param open
 *            True if Panel is to be opened, false if Panel is to be closed.
 * @param animate
 *            True if use animation, false otherwise.
 * 
 * @return True if operation was performed, false otherwise.
 * 
 */
public boolean setOpen(boolean open, boolean animate) {
    if (mState == State.READY && isOpen() ^ open) {
        mIsShrinking = !open;
        if (animate) {
            mState = State.ABOUT_TO_ANIMATE;
            if (!mIsShrinking) {
                // this could make flicker so we test mState in
                // dispatchDraw()
                // to see if is equal to ABOUT_TO_ANIMATE
                mContent.setVisibility(VISIBLE);
            }
            post(startAnimation);
        } else {
            mContent.setVisibility(open ? VISIBLE : GONE);
            postProcess();
        }
        return true;
    }
    return false;
}

/**
 * Returns the opened status for Panel.
 * 
 * @return True if Panel is opened, false otherwise.
 */
public boolean isOpen() {
    return mContent.getVisibility() == VISIBLE;
}

@Override
protected void onFinishInflate() {
    super.onFinishInflate();
    mHandle = findViewById(mHandleId);
    if (mHandle == null) {
        String name = getResources().getResourceEntryName(mHandleId);
        throw new RuntimeException(
                "Your Panel must have a child View whose id attribute is 'R.id."
                        + name + "'");
    }
    mHandle.setOnTouchListener(touchListener);
    mHandle.setOnClickListener(clickListener);

    mContent = findViewById(mContentId);
    if (mContent == null) {
        String name = getResources().getResourceEntryName(mHandleId);
        throw new RuntimeException(
                "Your Panel must have a child View whose id attribute is 'R.id."
                        + name + "'");
    }

    // reposition children
    removeView(mHandle);
    removeView(mContent);
    if (mPosition == TOP || mPosition == LEFT) {
        addView(mContent);
        addView(mHandle);
    } else {
        addView(mHandle);
        addView(mContent);
    }

    if (mClosedHandle != null) {
        mHandle.setBackgroundDrawable(mClosedHandle);
    }
    mContent.setClickable(true);
    mContent.setVisibility(GONE);
    if (mWeight > 0) {
        ViewGroup.LayoutParams params = mContent.getLayoutParams();
        if (mOrientation == VERTICAL) {
            params.height = ViewGroup.LayoutParams.FILL_PARENT;
        } else {
            params.width = ViewGroup.LayoutParams.FILL_PARENT;
        }
        mContent.setLayoutParams(params);
    }
}

@Override
protected void onAttachedToWindow() {
    super.onAttachedToWindow();
    ViewParent parent = getParent();
    if (parent != null && parent instanceof FrameLayout) {
        mBringToFront = true;
    }
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    if (mWeight > 0 && mContent.getVisibility() == VISIBLE) {
        View parent = (View) getParent();
        if (parent != null) {
            if (mOrientation == VERTICAL) {
                heightMeasureSpec = MeasureSpec.makeMeasureSpec(
                        (int) (parent.getHeight() * mWeight),
                        MeasureSpec.EXACTLY);
            } else {
                widthMeasureSpec = MeasureSpec.makeMeasureSpec(
                        (int) (parent.getWidth() * mWeight),
                        MeasureSpec.EXACTLY);
            }
        }
    }
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    super.onLayout(changed, l, t, r, b);
    mContentWidth = mContent.getWidth();
    mContentHeight = mContent.getHeight();
}

@Override
protected void dispatchDraw(Canvas canvas) {
    // String name = getResources().getResourceEntryName(getId());
    // Log.d(TAG, name + " ispatchDraw " + mState);
    // this is why 'mState' was added:
    // avoid flicker before animation start
    if (mState == State.ABOUT_TO_ANIMATE && !mIsShrinking) {
        int delta = mOrientation == VERTICAL ? mContentHeight
                : mContentWidth;
        if (mPosition == LEFT || mPosition == TOP) {
            delta = -delta;
        }
        if (mOrientation == VERTICAL) {
            canvas.translate(0, delta);
        } else {
            canvas.translate(delta, 0);
        }
    }
    if (mState == State.TRACKING || mState == State.FLYING) {
        canvas.translate(mTrackX, mTrackY);
    }
    super.dispatchDraw(canvas);
}

private float ensureRange(float v, int min, int max) {
    v = Math.max(v, min);
    v = Math.min(v, max);
    return v;
}

OnTouchListener touchListener = new OnTouchListener() {
    int initX;
    int initY;
    boolean setInitialPosition;

    public boolean onTouch(View v, MotionEvent event) {
        if (mState == State.ANIMATING) {
            // we are animating
            return false;
        }
        // Log.d(TAG, "state: " + mState + " x: " + event.getX() + " y: " +
        // event.getY());
        int action = event.getAction();
        if (action == MotionEvent.ACTION_DOWN) {
            if (mBringToFront) {
                bringToFront();
            }
            initX = 0;
            initY = 0;
            if (mContent.getVisibility() == GONE) {
                // since we may not know content dimensions we use factors
                // here
                if (mOrientation == VERTICAL) {
                    initY = mPosition == TOP ? -1 : 1;
                } else {
                    initX = mPosition == LEFT ? -1 : 1;
                }
            }
            setInitialPosition = true;
        } else {
            if (setInitialPosition) {
                // now we know content dimensions, so we multiply factors...
                initX *= mContentWidth;
                initY *= mContentHeight;
                // ... and set initial panel's position
                mGestureListener.setScroll(initX, initY);
                setInitialPosition = false;
                // for offsetLocation we have to invert values
                initX = -initX;
                initY = -initY;
            }
            // offset every ACTION_MOVE & ACTION_UP event
            event.offsetLocation(initX, initY);
        }
        if (!mGestureDetector.onTouchEvent(event)) {
            if (action == MotionEvent.ACTION_UP) {
                // tup up after scrolling
                post(startAnimation);
            }
        }
        return false;
    }
};

OnClickListener clickListener = new OnClickListener() {
    public void onClick(View v) {
        if (mBringToFront) {
            bringToFront();
        }
        if (initChange()) {
            post(startAnimation);
        }
    }
};

public boolean initChange() {
    if (mState != State.READY) {
        // we are animating or just about to animate
        return false;
    }
    mState = State.ABOUT_TO_ANIMATE;
    mIsShrinking = mContent.getVisibility() == VISIBLE;
    if (!mIsShrinking) {
        // this could make flicker so we test mState in dispatchDraw()
        // to see if is equal to ABOUT_TO_ANIMATE
        mContent.setVisibility(VISIBLE);
    }
    return true;
}

Runnable startAnimation = new Runnable() {
    public void run() {
        // this is why we post this Runnable couple of lines above:
        // now its save to use mContent.getHeight() && mContent.getWidth()
        TranslateAnimation animation;
        int fromXDelta = 0, toXDelta = 0, fromYDelta = 0, toYDelta = 0;
        if (mState == State.FLYING) {
            mIsShrinking = (mPosition == TOP || mPosition == LEFT)
                    ^ (mVelocity > 0);
        }
        int calculatedDuration;
        if (mOrientation == VERTICAL) {
            int height = mContentHeight;
            if (!mIsShrinking) {
                fromYDelta = mPosition == TOP ? -height : height;
            } else {
                toYDelta = mPosition == TOP ? -height : height;
            }
            if (mState == State.TRACKING) {
                if (Math.abs(mTrackY - fromYDelta) < Math.abs(mTrackY
                        - toYDelta)) {
                    mIsShrinking = !mIsShrinking;
                    toYDelta = fromYDelta;
                }
                fromYDelta = (int) mTrackY;
            } else if (mState == State.FLYING) {
                fromYDelta = (int) mTrackY;
            }
            // for FLYING events we calculate animation duration based on
            // flying velocity
            // also for very high velocity make sure duration >= 20 ms
            if (mState == State.FLYING && mLinearFlying) {
                calculatedDuration = (int) (1000 * Math
                        .abs((toYDelta - fromYDelta) / mVelocity));
                calculatedDuration = Math.max(calculatedDuration, 20);
            } else {
                calculatedDuration = mDuration
                        * Math.abs(toYDelta - fromYDelta) / mContentHeight;
            }
        } else {
            int width = mContentWidth;
            if (!mIsShrinking) {
                fromXDelta = mPosition == LEFT ? -width : width;
            } else {
                toXDelta = mPosition == LEFT ? -width : width;
            }
            if (mState == State.TRACKING) {
                if (Math.abs(mTrackX - fromXDelta) < Math.abs(mTrackX
                        - toXDelta)) {
                    mIsShrinking = !mIsShrinking;
                    toXDelta = fromXDelta;
                }
                fromXDelta = (int) mTrackX;
            } else if (mState == State.FLYING) {
                fromXDelta = (int) mTrackX;
            }
            // for FLYING events we calculate animation duration based on
            // flying velocity
            // also for very high velocity make sure duration >= 20 ms
            if (mState == State.FLYING && mLinearFlying) {
                calculatedDuration = (int) (1000 * Math
                        .abs((toXDelta - fromXDelta) / mVelocity));
                calculatedDuration = Math.max(calculatedDuration, 20);
            } else {
                calculatedDuration = mDuration
                        * Math.abs(toXDelta - fromXDelta) / mContentWidth;
            }
        }

        mTrackX = mTrackY = 0;
        if (calculatedDuration == 0) {
            mState = State.READY;
            if (mIsShrinking) {
                mContent.setVisibility(GONE);
            }
            postProcess();
            return;
        }

        animation = new TranslateAnimation(fromXDelta, toXDelta,
                fromYDelta, toYDelta);
        animation.setDuration(calculatedDuration);
        animation.setAnimationListener(animationListener);
        if (mState == State.FLYING && mLinearFlying) {
            animation.setInterpolator(new LinearInterpolator());
        } else if (mInterpolator != null) {
            animation.setInterpolator(mInterpolator);
        }
        startAnimation(animation);
    }
};

private AnimationListener animationListener = new AnimationListener() {
    public void onAnimationEnd(Animation animation) {
        mState = State.READY;
        if (mIsShrinking) {
            mContent.setVisibility(GONE);
        }
        postProcess();
    }

    public void onAnimationRepeat(Animation animation) {
    }

    public void onAnimationStart(Animation animation) {
        mState = State.ANIMATING;
    }
};

private void postProcess() {
    if (mIsShrinking && mClosedHandle != null) {
        mHandle.setBackgroundDrawable(mClosedHandle);
    } else if (!mIsShrinking && mOpenedHandle != null) {
        mHandle.setBackgroundDrawable(mOpenedHandle);
    }
    // invoke listener if any
    if (panelListener != null) {
        if (mIsShrinking) {
            panelListener.onPanelClosed(Panel.this);
        } else {
            panelListener.onPanelOpened(Panel.this);
        }
    }
}

class PanelOnGestureListener implements OnGestureListener {
    float scrollY;
    float scrollX;

    public void setScroll(int initScrollX, int initScrollY) {
        scrollX = initScrollX;
        scrollY = initScrollY;
    }

    public boolean onDown(MotionEvent e) {
        scrollX = scrollY = 0;
        initChange();
        return true;
    }

    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
            float velocityY) {
        mState = State.FLYING;
        mVelocity = mOrientation == VERTICAL ? velocityY : velocityX;
        post(startAnimation);
        return true;
    }

    public void onLongPress(MotionEvent e) {
        // not used
    }

    public boolean onScroll(MotionEvent e1, MotionEvent e2,
            float distanceX, float distanceY) {
        mState = State.TRACKING;
        float tmpY = 0, tmpX = 0;
        if (mOrientation == VERTICAL) {
            scrollY -= distanceY;
            if (mPosition == TOP) {
                tmpY = ensureRange(scrollY, -mContentHeight, 0);
            } else {
                tmpY = ensureRange(scrollY, 0, mContentHeight);
            }
        } else {
            scrollX -= distanceX;
            if (mPosition == LEFT) {
                tmpX = ensureRange(scrollX, -mContentWidth, 0);
            } else {
                tmpX = ensureRange(scrollX, 0, mContentWidth);
            }
        }
        if (tmpX != mTrackX || tmpY != mTrackY) {
            mTrackX = tmpX;
            mTrackY = tmpY;
            invalidate();
        }
        return true;
    }

    public void onShowPress(MotionEvent e) {
        // not used
    }

    public boolean onSingleTapUp(MotionEvent e) {
        // not used
        return false;
    }
}

}

Configured it finally. Just one line of code was messing up the whole application. Just changed that line and application was up and running. Posting the solution so it may help someone in future. This line should be changed in layout file

xmlns:panel="http://schemas.android.com/apk/res-auto"