Android 单机器人寻呼机

monodroid开发者可以使用ViewPager吗？我看过很多关于Android的教程：

我可以执行此操作并将ViewPager声明为代码，例如：

using Android.Support.V4.Widget;

namespace ViewPagerTest
{
    [Activity(Label = "ViewPager", MainLauncher = true, Icon = "@drawable/icon")]
    public class Activity1 : Activity
    {
        int count = 1;

        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            ViewPager pager = new ViewPager( this );

            SetContentView(Resource.Layout.Main);

        }
    }
}

但在本教程中，他使用了如下xml代码：

<android.support.v4.view.ViewPager
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

哪个机器人似乎不喜欢。。

---

有什么我遗漏的吗？

不是对你问题的直接回答

但是有人把一个单独的可视传呼机移植到MonoDroid上：

然后我添加了一个基于

//原贷记人：
// https://github.com/brucejcooper/Android-Examples/blob/master/PagingScrollerExample/src/com/eightbitcloud/pagingscroller/PageIndicator.java
公共类水平页面指示器：视图
{
私人水平寻呼机；
私人涂料(textPaint),；
私人涂料(不作为涂料);；
私人涂料(dotPaint),；
私人涂料(背景涂料),；
私人内部文本高度；
私人内部上升；
私人国际单位大小；
私人浮动(显示密度);；
公共水平页面指示器（上下文上下文、IAttributeSet属性）
：base（上下文、属性）
{
（上下文）；
}
公共水平页面指示器（上下文）
：基本（上下文）
{
（上下文）；
}
私有void InitPaints（上下文）
{
_displayDensity=context.Resources.DisplayMetrics.Density；
_textPaint=new Paint{antialas=true，TextSize=DeviceIndependentToPixels（14），Color=Color.Black}；
_InactiveVedotPaint=new Paint{AntiAlias=true，Color=Color.Gray}；
_dotPaint=newpaint{antialas=true，Color=Color.White}；
_dotBackgroundPaint=newpaint{antialas=true，Color=Color.Cyan}；
_上升=-（int）u textPaint.ascent（）；
_text高度=（int）（_上升+_textPaint.下降（））；
_cellSize=设备独立像素（_textHeight+6）；
}
公共水平寻呼机
{
获取{return\u pager；}
设置{
如果（_pager！=null）
{
_pager.ScreenChanged-=PagerOnScreenChanged；
}
_寻呼机=值；
如果（_pager！=null）
{
_pager.ScreenChanged+=PagerOnScreenChanged；
}
UpdatePageCount（）；
}
}
private void PagerOnScreenChanged（对象发送者，EventArgs EventArgs）
{
使无效（）；
}
public void UpdatePageCount（）
{
RequestLayout（）；
使无效（）；
}
私人整数
{
得到
{
返回_pager==null？1:_pager.ChildCount；
}
}
私有int活动页
{
得到
{
返回_pager==null？0:_pager.CurrentScreen；
}
}
测量时受保护的覆盖无效（int-widthMeasureSpec、int-heightMeasureSpec）
{
设置测量尺寸（测量宽度（宽度测量等级）、测量高度（高度测量等级））；
}
专用整数测量宽度（整数测量长度）
{
var结果=0；
var specMode=MeasureSpec.GetMode（MeasureSpec）；
var specSize=MeasureSpec.GetSize（MeasureSpec）；
if（specMode==MeasureSpecMode.justice）
{
//我们被告知要有多大
结果=规格尺寸；
}
其他的
{
结果=单位*单元大小；
if（specMode==MeasureSpecMode.AtMost）
{
//尊重是最有价值的，如果这是
//测量
结果=数学最小值（结果、规格尺寸）；
}
}
返回结果；
}
私有整数度量权重（整数度量）
{
var结果=0；
var specMode=MeasureSpec.GetMode（MeasureSpec）；
var specSize=MeasureSpec.GetSize（MeasureSpec）；
if（specMode==MeasureSpecMode.justice）
{
//我们被告知要有多大
结果=规格尺寸；
}
其他的
{
结果=_细胞大小；
if（specMode==MeasureSpecMode.AtMost）
{
//尊重是最有价值的，如果这是
//测量
结果=数学最小值（结果、规格尺寸）；
}
}
返回结果；
}
受保护的覆盖无效OnDraw（画布）
{
底座.OnDraw（帆布）；
var numPages=numPages；
var activePageIndex=ActivePage；
var x=（canvas.Width-numPages*_cellSize）/2；
//var smallBorder=_cellSize/4；
//var slitlysmallerborder=smallBorder-1；
var emptyDotSize=_cellSize/4；
var dotOffset=（_cellSize-emptyDotSize）/2；
对于（变量i=0；i// original credit to: 
// https://github.com/brucejcooper/Android-Examples/blob/master/PagingScrollerExample/src/com/eightbitcloud/pagingscroller/PageIndicator.java
public class HorizontalPagerIndicator : View
{
    private HorizontalPager _pager;
    private Paint _textPaint;
    private Paint _inactiveDotPaint;
    private Paint _dotPaint;
    private Paint _dotBackgroundPaint;
    private int _textHeight;
    private int _ascent;
    private int _cellSize;
    private float _displayDensity;

    public HorizontalPagerIndicator(Context context, IAttributeSet attrs)
        : base(context, attrs)
    {
        InitPaints(context);
    }


    public HorizontalPagerIndicator(Context context)
        : base(context)
    {
        InitPaints(context);
    }

    private void InitPaints(Context context)
    {
        _displayDensity = context.Resources.DisplayMetrics.Density;

        _textPaint = new Paint {AntiAlias = true, TextSize = DeviceIndependentToPixels(14), Color = Color.Black};

        _inactiveDotPaint = new Paint { AntiAlias = true, Color = Color.Gray };
        _dotPaint = new Paint {AntiAlias = true, Color = Color.White};
        _dotBackgroundPaint = new Paint { AntiAlias = true, Color = Color.Cyan };

        _ascent = -(int)_textPaint.Ascent();
        _textHeight = (int)(_ascent + _textPaint.Descent());
        _cellSize = DeviceIndependentToPixels(_textHeight + 6);
    }


    public HorizontalPager Pager
    {
        get { return _pager; }
        set  {

            if (_pager != null)
            {
                _pager.ScreenChanged -= PagerOnScreenChanged;
            }
            _pager = value;
            if (_pager != null)
            {
                _pager.ScreenChanged += PagerOnScreenChanged;
            }
            UpdatePageCount();
        }
    }

    private void PagerOnScreenChanged(object sender, EventArgs eventArgs)
    {
        Invalidate();
    }

    public void UpdatePageCount()
    {
        RequestLayout();
        Invalidate();
    }

    private int NumPages
    {
        get
        {
            return _pager == null ? 1 : _pager.ChildCount;
        }
    }

    private int ActivePage
    {
        get
        {
            return _pager == null ? 0 : _pager.CurrentScreen;
        }
    }

    protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
    {
        SetMeasuredDimension(MeasureWidth(widthMeasureSpec), MeasureHeight(heightMeasureSpec));
    }

    private int MeasureWidth(int measureSpec)
    {
        var result = 0;
        var specMode = MeasureSpec.GetMode(measureSpec);
        var specSize = MeasureSpec.GetSize(measureSpec);

        if (specMode == MeasureSpecMode.Exactly)
        {
            // We were told how big to be
            result = specSize;
        }
        else
        {
            result = NumPages * _cellSize;
            if (specMode == MeasureSpecMode.AtMost)
            {
                // Respect AT_MOST value if that was what is called for by
                // measureSpec
                result = Math.Min(result, specSize);
            }
        }
        return result;
    }

    private int MeasureHeight(int measureSpec)
    {
        var result = 0;
        var specMode = MeasureSpec.GetMode(measureSpec);
        var specSize = MeasureSpec.GetSize(measureSpec);


        if (specMode == MeasureSpecMode.Exactly)
        {
            // We were told how big to be
            result = specSize;
        }
        else
        {
            result = _cellSize;
            if (specMode == MeasureSpecMode.AtMost)
            {
                // Respect AT_MOST value if that was what is called for by
                // measureSpec
                result = Math.Min(result, specSize);
            }
        }
        return result;
    }

    protected override void OnDraw(Canvas canvas)
    {
        base.OnDraw(canvas);

        var numPages = NumPages;
        var activePageIndex = ActivePage;

        var x = (canvas.Width - numPages * _cellSize)/2;

        //var smallBorder = _cellSize/4;
        //var slightlySmallerBorder = smallBorder - 1;
        var emptyDotSize = _cellSize/4;
        var dotOffset = (_cellSize - emptyDotSize) / 2;
        for (var i = 0; i < numPages; i++, x += _cellSize)
        {
            if (i == activePageIndex)
            {
                //var txt = (i + 1).ToString(System.Globalization.CultureInfo.CurrentUICulture);
                //var bounds = new Rect();
                //_textPaint.GetTextBounds(txt, 0, txt.Length, bounds);
                //var oval = new RectF(x + smallBorder, smallBorder, x + _cellSize - smallBorder, _cellSize - smallBorder);
                var oval = new RectF(x + dotOffset, dotOffset, x + dotOffset + emptyDotSize, dotOffset + emptyDotSize);
                var oval1 = new RectF(x + dotOffset - 1, dotOffset - 1, x + dotOffset + emptyDotSize + 1, dotOffset + emptyDotSize + 1);
                canvas.DrawOval(oval1, _dotBackgroundPaint);
                canvas.DrawOval(oval, _dotPaint);
                //canvas.DrawText(txt, x + (_cellSize - bounds.Width()) / 2, (_cellSize - _textHeight) / 2 + _ascent, _textPaint);
            }
            else
            {
                var oval = new RectF(x + dotOffset, dotOffset, x + dotOffset + emptyDotSize, dotOffset + emptyDotSize);
                canvas.DrawOval(oval, _inactiveDotPaint);
            }
        }
    }

    private int DeviceIndependentToPixels(int dpi)
    {
        return (int)Math.Round((float)dpi * _displayDensity);
    }
}