AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android 自定义坐标曲线图

2023-11-23 78
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 自定义View，使用paint、point、path，画点、点与点连接成线、然后闭合起来就是一个多边形，画坐标，实现坐标曲线图

先看效果
image.png
项目开发中，被安排去调研实现 坐标曲线图，网上第三方的库很多，可以实现，但是有些样式无法做到符合自己要求，Android 与iOS效果上也存在差异，所以自己自定义了一个；

其实比较简单，就是画点，画线，画虚线，画曲线，添加点击事件即可；这里面需要涉及到的知识点主要是有：对自定义View有一点基础，比如onMeasure()、onLayout()、onDraw()；至少得了解这三个方法；

另外就是需要会用画笔Paint、点Point、路径Path等，至少会使用这三个API，那基本就没有问题了，画点、点与点连接成线、然后闭合起来就是一个多边形、再给多边形填充颜色即可；

另外横坐标纵坐标，以及点的数据，都是外部传入，具体情况具体考虑；

先看使用方法：

在布局中添加

<com.test.jsontouijson.weight.LineGraphicView
        android:id="@+id/lineGraphicView"
        android:layout_weight="1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>

在activity或fragment中初始化，添加数据

lineGraphicView = findViewById(R.id.lineGraphicView); 
lineGraphicView.setData(pointData);
//添加点击事件
lineGraphicView.setListener((x, y) -> initPopupWindow(lineGraphicView, x, y));

点击后的弹框是外部实现的，这个自行使用popupWindow去实现，点击已经有返回点的坐标x、y了，弹框的显示位置可通过这个坐标点定位。

大概就是这些，下面是LineGraphicView具体代码，代码有比较详细的备注形式


import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.DashPathEffect;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.Shader;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class LineGraphicView extends View {
    private static final int CIRCLE_SIZE = 40;

    private static enum LineStyle {LINE, CURVE}

    private static enum YLineStyle {DASHES_LINE, FULL_LINE}

    private static enum ShaderOrientationStyle {ORIENTATION_H, ORIENTATION_V}

    private Context mContext;
    private Resources res;
    private DisplayMetrics dm;
    private OnClickListener listener;
    private LineStyle mStyle = LineStyle.LINE;
    private YLineStyle mYLineStyle = YLineStyle.DASHES_LINE;
    private ShaderOrientationStyle mShaderOrientationStyle = ShaderOrientationStyle.ORIENTATION_V;
    private int canvasHeight;
    private int canvasWidth;
    private int bHeight = 0;
    private int bWidth = 0;
    private int marginLeft;
    private boolean isMeasure = true;
    private boolean isShowFirstXContent = false;
    private int xTextWidth = 0;//Y轴内容宽度
    private int spacingHeight;
    private double averageValue;
    private int marginTop = 0;
    private int marginBottom = 0;
    /**
     * data
     */
    private Point[] mPoints;//点
    private List<String> yRawDatas;//y轴数据
    private PointData pointData;//外部传入数据
    private List<String> xRawDatas;//x轴数据
    private List<Double> dataList = new ArrayList<>();//点的数据
    private List<Integer> xList = new ArrayList<>();// 记录每个x的值
    private Map<String, Integer> xMap = new HashMap<>();//用于保存 点-X坐标 对应起来
    /**
     * paint color
     */
    private int xTextPaintColor;
    private int yTextPaintColor;
    private int startShaderColor;
    private int endShaderColor;
    private int mCanvasColor;
    /**
     * paint size
     */
    private int xTextSize = 12;
    private int yTextSize = 12;
    private Point mSelPoint;


    public LineGraphicView(Context context) {
        this(context, null);
    }

    public LineGraphicView(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.mContext = context;
        initView();
    }

    private void initView() {
        this.res = mContext.getResources();
        xTextPaintColor = res.getColor(R.color.black);
        yTextPaintColor = res.getColor(R.color.black);
        startShaderColor = res.getColor(R.color.colorYellow);
        endShaderColor = res.getColor(R.color.colorYellow1);
        mCanvasColor = res.getColor(R.color.colorGray1);
        dm = new DisplayMetrics();
        WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        wm.getDefaultDisplay().getMetrics(dm);
    }

    public void setData(PointData pointData) {
        this.pointData = pointData;
        this.averageValue = pointData.getyAverageValue();
        this.xRawDatas = pointData.getxAxis();
        this.yRawDatas = pointData.getyAxis();
        for (int i = 0; i < pointData.getPointInfo().size(); i++) {
            dataList.add(pointData.getPointInfo().get(i).getPrice());
        }
        if (null != dataList) {
            this.mPoints = new Point[dataList.size()];
        }
        if (null != yRawDatas) {
            this.spacingHeight = yRawDatas.size();
        }
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        if (isMeasure) {
            marginLeft = dip2px(30);
            marginTop = dip2px(30);
            marginBottom = dip2px(80);
            this.canvasHeight = getHeight();//获取画布高度
            this.canvasWidth = getWidth();//获取画布宽度
            if (bHeight == 0) {
                bHeight = getHeight() - marginBottom;//实际坐标图高度
            }
            if (bWidth == 0) {
                bWidth = canvasWidth - marginLeft;//实际坐标图宽度
            }
            isMeasure = false;
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        //draw X line
        drawAllXLine(canvas);
        if (YLineStyle.DASHES_LINE == mYLineStyle) {
            drawPathYDashesLine(canvas);//draw Y dashes line
        } else {
            drawAllYLine(canvas);// draw Y ine）
        }
        // point init
        mPoints = getPoints();
        //draw cure line
        drawCurve(canvas);
        //draw Polygon bg color
        drawPolygonBgColor(canvas);
        // is click point
        if (null == mSelPoint) {
            drawDot(canvas);// draw dot
        } else {
            clickUpdateDot(canvas);// update dot after click
        }
        canvas.drawColor(mCanvasColor);//canvas color
    }

    private void drawCurve(Canvas c) {
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setColor(res.getColor(R.color.colorPrimaryDark));
        p.setStrokeWidth(dip2px(0.5f));
        p.setStyle(Paint.Style.STROKE);
        if (mStyle == LineStyle.CURVE) {
            drawScrollLine(c, p);
        } else {
            drawLine(c, p);
        }
    }

//画点
    private void drawDot(Canvas c) {
        if (null == mPoints || mPoints.length == 0) {
            return;
        }
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setStyle(Paint.Style.FILL);
        for (Point point : mPoints) {
            p.setColor(res.getColor(R.color.colorYellow2));
            c.drawCircle(point.x, point.y, CIRCLE_SIZE / 2, p);
            p.setColor(res.getColor(R.color.colorYellow3));
            c.drawCircle(point.x, point.y, CIRCLE_SIZE / 3, p);
        }
    }

//更新点
    private void clickUpdateDot(Canvas c) {
        if (null == mPoints || mPoints.length == 0) {
            return;
        }
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setStyle(Paint.Style.FILL);
        for (Point point : mPoints) {
            if (null != mSelPoint && mSelPoint.x == point.x && mSelPoint.y == point.y) {
                p.setColor(res.getColor(R.color.colorPrimary));
                c.drawCircle(point.x, point.y, CIRCLE_SIZE, p);
                p.setColor(res.getColor(R.color.colorYellow3));
                c.drawCircle(point.x, point.y, (float) (CIRCLE_SIZE / 1.5), p);
            } else {
                p.setColor(res.getColor(R.color.colorYellow2));
                c.drawCircle(point.x, point.y, CIRCLE_SIZE / 2, p);
                p.setColor(res.getColor(R.color.colorYellow3));
                c.drawCircle(point.x, point.y, CIRCLE_SIZE / 3, p);
            }
        }
    }

//填充曲线闭合起来的图
    private void drawPolygonBgColor(Canvas c) {
        if (null == mPoints || mPoints.length == 0) {
            return;
        }
        Path p = new Path();
        float startX = 0;
        float endX = 0;
        int endPoint = mPoints.length - 1;
        for (int i = 0; i < mPoints.length; i++) {
            if (i == 0) {
                startX = mPoints[i].x;
                p.moveTo(mPoints[i].x, 0);
                p.lineTo(mPoints[i].x, mPoints[i].y);
            } else {
                p.lineTo(mPoints[i].x, mPoints[i].y);
                if (i == endPoint) {
                    endX = mPoints[i].x;
                }
            }
        }
        p.lineTo(endX, bHeight + marginTop);
        p.lineTo(startX, bHeight + marginTop);
        p.close();
        Paint paint = new Paint();
        paint.setStyle(Paint.Style.FILL);
        Shader shader = null;
        if (mShaderOrientationStyle == ShaderOrientationStyle.ORIENTATION_H) {
            shader = new LinearGradient(endX, bHeight + marginTop, startX, bHeight + marginTop,
                    startShaderColor, endShaderColor, Shader.TileMode.REPEAT);
        } else {
            Point point = getYBiggestPoint();
            if (null != point) {
                shader = new LinearGradient(point.x, point.y, endX, bHeight + marginTop,
                        startShaderColor, endShaderColor, Shader.TileMode.REPEAT);
            }
        }
        paint.setShader(shader);
        c.drawPath(p, paint);
    }

//获取Y坐标最高的点
    private Point getYBiggestPoint() {
        Point p = null;
        if (null != mPoints && mPoints.length > 0) {
            p = mPoints[0];
            for (int i = 0; i < mPoints.length - 1; i++) {
                if (p.y > mPoints[i + 1].y) {
                    p = mPoints[i + 1];
                }
            }
        }
        return p;
    }

//画Y方向虚线
    private void drawPathYDashesLine(Canvas canvas) {
        if (null == xRawDatas || xRawDatas.size() == 0) {
            return;
        }
        Path path = new Path();
        int dashLength = 16;
        int blankLength = 16;
        Paint p = new Paint();
        p.setStyle(Paint.Style.STROKE);
        p.setStrokeWidth(4);
        p.setColor(res.getColor(R.color.colorGray));
        p.setPathEffect(new DashPathEffect(new float[]{dashLength, blankLength}, 0));
        if (!isShowFirstXContent && null == mSelPoint) {
            xRawDatas.add(0, "");
        }
        for (int i = 0; i < xRawDatas.size(); i++) {
            drawTextY(xRawDatas.get(i), (getMarginWidth() + getBWidth() / xRawDatas.size() * i) - dip2px(8), bHeight + marginTop + dip2px(26),
                    canvas);
            if (null != xMap) {
                xMap.put(xRawDatas.get(i), getMarginWidth() + getBWidth() / xRawDatas.size() * i);
            }
            float startX = getMarginWidth() + getBWidth() / xRawDatas.size() * i;
            float startY = marginTop;
            float endY = bHeight + marginTop;
            path.moveTo(startX, startY);
            path.lineTo(startX, endY);
            canvas.drawPath(path, p);
        }
        getPointX();
    }

    /**
     * 画所有Y方向实线
     */
    private void drawAllYLine(Canvas canvas) {
        if (null == xRawDatas || xRawDatas.size() == 0) {
            return;
        }
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setColor(res.getColor(R.color.colorBlack));
        for (int i = 0; i < xRawDatas.size(); i++) {
            canvas.drawLine(getMarginWidth() + getBWidth() / xRawDatas.size() * i, marginTop, getMarginWidth()
                    + getBWidth() / xRawDatas.size() * i, bHeight + marginTop, p);
            drawTextY(xRawDatas.get(i), getMarginWidth() + getBWidth() / xRawDatas.size() * i - dip2px(8), bHeight + marginTop + dip2px(26),
                    canvas);
            if (null != xMap) {
                xMap.put(xRawDatas.get(i), getMarginWidth() + getBWidth() / xRawDatas.size() * i);
            }
        }
        getPointX();
    }

//获取点的X坐标
    private void getPointX() {
        if (null == xMap || xMap.size() == 0) {
            return;
        }
        if (null != pointData && pointData.getPointInfo().size() > 0) {
            for (PointData.PointInfo info : pointData.getPointInfo()) {
                for (String key : xMap.keySet()) {
                    if (key.equals(info.getMouth())) {
                        xList.add(xMap.get(key));
                    }
                }
            }
        }
    }

    /**
     * 画所有X方向的线
     */
    private void drawAllXLine(Canvas canvas) {
        if (null == yRawDatas || yRawDatas.size() == 0) {
            return;
        }
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setColor(res.getColor(R.color.colorBlack));
        p.setStyle(Paint.Style.FILL);
        for (int i = 0; i < yRawDatas.size(); i++) {
            drawTextX(yRawDatas.get(i), marginLeft / 2,
                    bHeight - (bHeight / spacingHeight) * i + marginTop + dip2px(2), canvas);
            canvas.drawLine(getMarginWidth(), bHeight - (bHeight / spacingHeight) * i + marginTop, canvasWidth,
                    bHeight - (bHeight / spacingHeight) * i + marginTop, p);// Y坐标
        }
    }

//画圆滑的曲线
    private void drawScrollLine(Canvas canvas, Paint paint) {
        if (null == mPoints || mPoints.length == 0) {
            return;
        }
        Point startP;
        Point endP;
        for (int i = 0; i < mPoints.length - 1; i++) {
            startP = mPoints[i];
            endP = mPoints[i + 1];
            int wt = (startP.x + endP.x) / 2;
            Point p3 = new Point();
            Point p4 = new Point();
            p3.y = startP.y;
            p3.x = wt;
            p4.y = endP.y;
            p4.x = wt;
            Path path = new Path();
            path.moveTo(startP.x, startP.y);
            path.cubicTo(p3.x, p3.y, p4.x, p4.y, endP.x, endP.y);
            canvas.drawPath(path, paint);
        }
    }

//画笔直的曲线
    private void drawLine(Canvas canvas, Paint paint) {
        if (null == mPoints || mPoints.length == 0) {
            return;
        }
        Point startP;
        Point endP;
        for (int i = 0; i < mPoints.length - 1; i++) {
            startP = mPoints[i];
            endP = mPoints[i + 1];
            canvas.drawLine(startP.x, startP.y, endP.x, endP.y, paint);
        }
    }

//添加X轴方向的文字
    private void drawTextY(String text, int x, int y, Canvas canvas) {
        if (null == yRawDatas || yRawDatas.size() == 0) {
            return;
        }
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setTextSize(dip2px(yTextSize));
        p.setColor(yTextPaintColor);
        p.setTextAlign(Paint.Align.LEFT);
        canvas.drawText(text, x, y, p);
    }

//添加Y轴方向的文字
    private void drawTextX(String text, int x, int y, Canvas canvas) {
        if (null == xRawDatas || xRawDatas.size() == 0) {
            return;
        }
        Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
        p.setTextSize(dip2px(xTextSize));
        p.setColor(xTextPaintColor);
        p.setTextAlign(Paint.Align.LEFT);
        xTextWidth = (int) p.measureText(text);
        canvas.drawText(text, x, y, p);
    }

//获取所有曲线点
    private Point[] getPoints() {
        Point[] points = new Point[dataList.size()];
        for (int i = 0; i < dataList.size(); i++) {
            int ph = bHeight - (int) (((dataList.get(i) - pointData.getyAxisSmallValue()) / averageValue) * (bHeight / spacingHeight));
            points[i] = new Point(xList.get(i), ph + marginTop);
        }
        return points;
    }

//获取实际的左边距
    private int getMarginWidth() {
        if (xTextWidth == 0) {
            return marginLeft;
        } else {
            return xTextWidth + marginLeft;
        }
    }

//获取实际的坐标图宽度
    private int getBWidth() {
        if (xTextWidth == 0) {
            return bWidth;
        } else {
            return bWidth - xTextWidth;
        }
    }


    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int x = (int) event.getX();
        int y = (int) event.getY();
        int action = event.getAction();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                dealClick(x, y);
                break;
        }
        return true;
    }

//添加点击事件，并更新点
    private void dealClick(int x, int y) {
        if (null != mPoints && mPoints.length > 0) {
            for (int i = 0; i < mPoints.length; i++) {
                if ((mPoints[i].x - CIRCLE_SIZE) < x && x < (mPoints[i].x + CIRCLE_SIZE) &&
                        (mPoints[i].y - CIRCLE_SIZE) < y && y < (mPoints[i].y + CIRCLE_SIZE)) {
                    mSelPoint = mPoints[i];
                    invalidate();
                    if (null != listener) {
                        listener.onClick(mPoints[i].x, mPoints[i].y);
                    }
                    Toast.makeText(mContext, "点击了第" + i + "个", Toast.LENGTH_SHORT).show();
                }
            }
        }
    }


    public void setAverageValue(int averageValue) {
        this.averageValue = averageValue;
    }

    public void setMarginTop(int marginTop) {
        this.marginTop = marginTop;
    }

    public void setMarginBottom(int marginBottom) {
        this.marginBottom = marginBottom;
    }

    public void setMStyle(LineStyle mStyle) {
        this.mStyle = mStyle;
    }

    public void setMYLineStyle(YLineStyle style) {
        this.mYLineStyle = style;
    }

    public void setShaderOrientationStyle(ShaderOrientationStyle shaderOrientationStyle) {
        this.mShaderOrientationStyle = shaderOrientationStyle;
    }

    public void setBHeight(int bHeight) {
        this.bHeight = bHeight;
    }

    public void setXTextPaintColor(int xTextPaintColor) {
        this.xTextPaintColor = xTextPaintColor;
    }


    public void setYTextPaintColor(int yTextPaintColor) {
        this.yTextPaintColor = yTextPaintColor;
    }


    public void setXTextSize(int xTextSize) {
        this.xTextSize = xTextSize;
    }

    public void setYTextSize(int yTextSize) {
        this.yTextSize = yTextSize;
    }

    public void setShaderColor(int startColor, int endColor) {
        this.startShaderColor = startColor;
        this.endShaderColor = endColor;
    }

    public void setIsShowFirstXContent(boolean isShowFirstXContent) {
        this.isShowFirstXContent = isShowFirstXContent;
    }

    /**
     * 根据手机的分辨率从 dp 的单位 转成为 px(像素)
     */
    private int dip2px(float dpValue) {
        return (int) (dpValue * dm.density + 0.5f);
    }

    public interface OnClickListener {
        void onClick(int x, int y);
    }

    public void setListener(OnClickListener listener) {
        this.listener = listener;
    }

}

that's all

文章标签：
Android开发
iOS开发
API
关键词：
Android自定义
Android曲线
Android图
Android坐标
Android自定义曲线
小陆要努力
目录
相关文章
shuj
|
1月前
|
Android开发 开发者
安卓应用开发中的自定义视图
【9月更文挑战第37天】在安卓开发的海洋中，自定义视图犹如一座座小岛，等待着勇敢的探索者去发现其独特之处。本文将带领你踏上这段旅程，从浅滩走向深海，逐步揭开自定义视图的神秘面纱。
shuj
41 3
shuj
|
1月前
|
数据可视化 Android开发 开发者
安卓应用开发中的自定义View组件
【10月更文挑战第5天】在安卓应用开发中，自定义View组件是提升用户交互体验的利器。本篇将深入探讨如何从零开始创建自定义View，包括设计理念、实现步骤以及性能优化技巧，帮助开发者打造流畅且富有创意的用户界面。
shuj
85 0
天下无贼001
|
17天前
|
搜索推荐 前端开发 Android开发
安卓应用开发中的自定义视图实现
【10月更文挑战第30天】在安卓开发的海洋中，自定义视图是那抹不可或缺的亮色，它为应用界面的个性化和交互体验的提升提供了无限可能。本文将深入探讨如何在安卓平台创建自定义视图，并展示如何通过代码实现这一过程。我们将从基础出发，逐步引导你理解自定义视图的核心概念，然后通过一个实际的代码示例，详细讲解如何将理论应用于实践，最终实现一个美观且具有良好用户体验的自定义控件。无论你是想提高自己的开发技能，还是仅仅出于对安卓开发的兴趣，这篇文章都将为你提供价值。
天下无贼001
32 4
shuj
|
19天前
|
Android开发 开发者 UED
安卓开发中自定义View的实现与性能优化
【10月更文挑战第28天】在安卓开发领域，自定义View是提升应用界面独特性和用户体验的重要手段。本文将深入探讨如何高效地创建和管理自定义View，以及如何通过代码和性能调优来确保流畅的交互体验。我们将一起学习自定义View的生命周期、绘图基础和事件处理，进而探索内存和布局优化技巧，最终实现既美观又高效的安卓界面。
shuj
28 5
游客moiomvrp3vyac2
|
1月前
|
XML 前端开发 Java
安卓应用开发中的自定义View组件
【10月更文挑战第5天】自定义View是安卓应用开发的一块基石，它为开发者提供了无限的可能。通过掌握其原理和实现方法，可以创造出既美观又实用的用户界面。本文将引导你了解自定义View的创建过程，包括绘制技巧、事件处理以及性能优化等关键步骤。
游客moiomvrp3vyac2
27 1
请看我回答~
|
3天前
|
开发框架 前端开发 Android开发
安卓与iOS开发中的跨平台策略
在移动应用开发的战场上，安卓和iOS两大阵营各据一方。随着技术的演进，跨平台开发框架成为开发者的新宠，旨在实现一次编码、多平台部署的梦想。本文将探讨跨平台开发的优势与挑战，并分享实用的开发技巧，帮助开发者在安卓和iOS的世界中游刃有余。
请看我回答~
16 1
游客qf4jmczx4xu2y
|
8天前
|
搜索推荐 Android开发 开发者
探索安卓开发中的自定义视图：打造个性化UI组件
【10月更文挑战第39天】在安卓开发的世界中，自定义视图是实现独特界面设计的关键。本文将引导你理解自定义视图的概念、创建流程，以及如何通过它们增强应用的用户体验。我们将从基础出发，逐步深入，最终让你能够自信地设计和实现专属的UI组件。
游客qf4jmczx4xu2y
25 4
请看我回答~
|
10天前
|
Android开发 Swift iOS开发
探索安卓与iOS开发的差异和挑战
【10月更文挑战第37天】在移动应用开发的广阔舞台上，安卓和iOS这两大操作系统扮演着主角。它们各自拥有独特的特性、优势以及面临的开发挑战。本文将深入探讨这两个平台在开发过程中的主要差异，从编程语言到用户界面设计，再到市场分布的不同影响，旨在为开发者提供一个全面的视角，帮助他们更好地理解并应对在不同平台上进行应用开发时可能遇到的难题和机遇。
请看我回答~
27 4
肥猪肥猪-17824
|
12天前
|
XML 存储 Java
探索安卓开发之旅：从新手到专家
【10月更文挑战第35天】在数字化时代，安卓应用的开发成为了一个热门话题。本文旨在通过浅显易懂的语言，带领初学者了解安卓开发的基础知识，同时为有一定经验的开发者提供进阶技巧。我们将一起探讨如何从零开始构建第一个安卓应用，并逐步深入到性能优化和高级功能的实现。无论你是编程新手还是希望提升技能的开发者，这篇文章都将为你提供有价值的指导和灵感。
肥猪肥猪-17824
27 4
肥猪肥猪-17824
|
10天前
|
存储 API 开发工具
探索安卓开发：从基础到进阶
【10月更文挑战第37天】在这篇文章中，我们将一起探索安卓开发的奥秘。无论你是初学者还是有经验的开发者，这篇文章都将为你提供有价值的信息和建议。我们将从安卓开发的基础开始，逐步深入到更复杂的主题，如自定义组件、性能优化等。最后，我们将通过一个代码示例来展示如何实现一个简单的安卓应用。让我们一起开始吧！
肥猪肥猪-17824
25 1

热门文章

最新文章

  • 1
    Android——Fragment介绍
  • 2
    android使用Activity
  • 3
    Android开发1——查找所需要出示权限的内容
  • 4
    大叔也说Xamarin~Android篇~Activity之间传递数组
  • 5
    离线安装Eclipse的Android ADT开发插件
  • 6
    传谷歌收紧 Android 厂商控制：力推自家应用
  • 7
    实现一个用于显示当前时间的Google Android 窗口小部件（AppWidget）
  • 8
    Android的Handler使用
  • 9
    Android响应式编程RxAndroid（1）：简单例程
  • 10
    Android学习之四大组件（四）——BroadcastReceiver
  • 1
    kotlin开发安卓app，如何让布局自适应系统传统导航和全面屏导航
    130
  • 2
    kotlin开发安卓app，使用webivew 触发 onShowFileChooser， 但只能触发一次，第二次无法触发，是怎么回事。 如何解决
    365
  • 3
    Android面试题之View的invalidate方法和postInvalidate方法有什么区别
    59
  • 4
    Android深入Binder拦截问题分析
    63
  • 5
    安卓与iOS开发环境对比：选择适合你的平台
    48
  • 6
    安卓与iOS开发环境对比：选择合适的平台
    48
  • 7
    使用kotlin Jetpack Compose框架开发安卓app， webview中h5如何访问手机存储上传文件
    159
  • 8
    探索安卓应用开发的未来趋势
    47
  • 9
    安卓与iOS开发环境对比分析
    51
  • 10
    Android studio 安装以及第一个程序
    133

    • 相关课程

    更多
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline

    • 推荐镜像

    更多
  • android.googlesource.com
    • 下一篇
    无影云桌面