androidclock
‘壹’ android main.xml里的DigitalClock怎么让它以24h制显示
代码可以实现，属性应该也可以实现。
int res = android.R.string.twenty_four_hour_time_format;
java.text.DateFormat format = new java.text.SimpleDateForma(context.getString(res));
dClock.setSummary(format.format(now));
‘贰’ android digitalclock 怎么设置自己想要的时间
@Override
protected void onAttachedToWindow() {
mTickerStopped = false;
super.onAttachedToWindow();
mHandler = new Handler();
/**
* requests a tick on the next hard-second boundary
*/
mTicker = new Runnable() {
public void run() {
if (mTickerStopped) return;
mCalendar.setTimeInMillis(System.currentTimeMillis());
setText(DateFormat.format(mFormat, mCalendar));
invalidate();
long now = SystemClock.uptimeMillis();
long next = now + (1000 - now % 1000);
mHandler.postAtTime(mTicker, next);
}
};
mTicker.run();
}
‘叁’ 如何在android下采用相对时间，实现超时等待的功能
一、函数功能说明
pthread_cond_timedwait 等待一个条件变量，或者超时就会返回
POSIX有两种时钟类型
1、CLOCK_REALTIME： 系统范围内的实时时钟,是个时钟,可以通过命令等方式修改该系统时间.
2、CLOCK_MONOTONIC：系统起机时到现在的时间,不能被设置和修改.
pthread_cond_timedwait()在没有设置条件变量属性的时候,默认用的是CLOCK_REALTIME时间,
因此在极端情况下会出现实际等待的时间与设置的超时时间不同。
所以，对于linux的超时等待功能，最好是使用CLOCK_MONOTONIC进行实现，并且通过pthread_condattr_setclock实现。
而对于android系统而言，是不支持pthread_condattr_setclock，通过验证可以采用函数pthread_cond_timedwait_monotonic实现。
下面直接给出代码的实现功能。
二、超时等待功能
[cpp] view plain
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/times.h>
#include <unistd.h>
#include <time.h>
static pthread_mutex_t s_mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_cond = PTHREAD_COND_INITIALIZER;
void PthreadAttr_Init(void);
unsigned long long getSysTime(void);
void waitTimeout(void);
void PthreadAttr_Init(void)
{
#if defined(ANDROID)
#else
pthread_condattr_t cattr;
int iRet = -1;
iRet = pthread_condattr_init(cattr);
if (iRet != 0)
{
return;
}
pthread_mutex_init(s_mut, NULL);
pthread_condattr_setclock(cattr, CLOCK_MONOTONIC);
pthread_cond_init(s_cond, cattr);
pthread_condattr_destroy(cattr);
#endif
return;
}
void waitTimeout(void)
{
unsigned long long ullbefore = getSysTime();
unsigned long long ullafter = 0;
#if defined(ANDROID)
#if defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC) // 支持ANDROID下NDK的编译，采用相对时间
struct timespec outtime;
memset(outtime, 0x00, sizeof(struct timespec ));
clock_gettime(CLOCK_MONOTONIC, outtime);
outtime.tv_sec += 2;
pthread_mutex_lock(s_mut);
pthread_cond_timedwait_monotonic(s_cond,s_mut, outtime);
pthread_mutex_unlock(s_mut);
ullafter = getSysTime();
printf("####01 interval[%lld] ms\n", ullafter - ullbefore);
#else //支持ANDROID下NDK的编译，采用绝对时间
struct timeval now;
struct itmespec outtime;
gettimeofday(now, NULL);
outtime.tv_sec = now..tv_sec + 3;
outtime.tv_nsec = now.tv_usec * 1000;
pthread_mutex_lock(s_mut);
pthread_cond_timedwait(s_cond, s_mut, outtime);
pthread_mutex_unlock(s_mut);
ullafter = getSysTime();
printf("####02 interval[%lld] ms\n", ullafter - ullbefore);
#endif
#else // 支持LINUX下的编译，采用绝对时间
struct timespec outtime;
memset(outtime, 0x00, sizeof(struct timespec ));
clock_gettime(CLOCK_MONOTONIC, outtime);
outtime.tv_sec += 4;
pthread_mutex_lock(s_mut);
pthread_cond_timedwait(s_cond, s_mut, outtime);
pthread_mutex_unlock(s_mut);
ullafter = getSysTime();
printf("####03 interval[%lld] ms\n", ullafter - ullbefore);
#endif
return;
}
unsigned long long getSysTime(void)
{
unsigned long long milliseconds = 0;
struct tms t_tmsTime;
clock_t t_CurTime;
static int s_clks_per_sec = 0;
if (s_clks_per_sec == 0)
{
s_clks_per_sec = sysconf(_SC_CLK_TCK);
}
if (s_clks_per_sec == 0)
{
return 0;
}
t_CurTime = times(t_tmsTime);
if (1000 % s_clks_per_sec == 0)
{
milliseconds = (1000 /s_clks_per_sec)*(unsigned long long )t_CurTime;//换算成毫秒
}
else
{
milliseconds = 1000 * (unsigned long long )t_CurTime/s_clks_per_sec;//换算成毫秒
}
return milliseconds;
}
int main(void)
{
PthreadAttr_Init();
waitTimeout();
return 0;
}
编译命令：
gcc test_ptthrad_conf_timewait_monotonic.c -o test_ptthrad_conf_timewait_monotonic -lpthread -lrt
linux下的测试结果：
####03 interval[4010] ms
‘肆’ android自带时钟应用的这个效果是怎么做的
次的小程序是一个Android小时钟。主要用到知识有Handler，Thread,Canvas,Path.
Handler:主要是用来接收子线程发送的数据，并用此数据配合主线程更新UI。Handler运行在主线程，通过message来与子线程传递数据。我只用到了sendMessage（Message）方法。
Thread在Java中刚学过了，所以用起来还是比较简单的，就不多说了。
Canvas类就是表示一块画布，你可以在上面画你想画的东西。当然，你还可以设置画布的属性，如画布的颜色/尺寸等。
这东西我是第一次用，所以查了下canvas提供的方法。在时钟小程序中，我主要用的是rotate(),旋转画布。
Path也是第一次用到。moveTo和lineTo是用来设置开始的基点和最后的基点。我用path来画时钟的分针、秒针和时针。
关于android画图方面的知识是第一次接触到，（其实本来是想从网上下载一个时钟表盘的图片直接拿来用的），但是由于找不到合适的指针的图片，所以还是用画的了，虽然这样就会显得很朴素了，但是基本功能还是实现了。截图如下：
importjava.util.Calendar;
importandroid.annotation.SuppressLint;
importandroid.content.Context;
importandroid.graphics.Canvas;
importandroid.graphics.Color;
importandroid.graphics.Paint;
importandroid.graphics.Path;
importandroid.view.View;
@SuppressLint({"ResourceAsColor","DrawAllocation"})
publicclassdrawextendsView{
publicdraw(Contextcontext){
super(context);
}
publicvoidonDraw(Canvascanvas){
Paintpaint=newPaint();
paint.setAntiAlias(true);
paint.setColor(Color.BLACK);
paint.setStyle(Paint.Style.STROKE);//空心的画笔
paint.setStrokeWidth(3);//设置paint的外框宽度
drawDial(canvas,paint);//绘制表盘
drawHand(canvas,paint);//绘制时针、分针、秒针
}
publicvoiddrawHand(Canvascanvas,Paintpaint){
intx=310;
inty=x;
inthour;
intminute;
intsecond;
finalCalendarcalendar=Calendar.getInstance();
hour=calendar.get(Calendar.HOUR);
minute=calendar.get(Calendar.MINUTE);
second=calendar.get(Calendar.SECOND);
floath=((hour+(float)minute/60)/12)*360;
floatm=((minute+(float)second/60)/60)*360;
floats=((float)second/60)*360;
//时针
paint.setColor(Color.WHITE);
canvas.save();//线锁定画布
canvas.rotate(h,x/2,y/2);//旋转画布
Pathpath1=newPath();
path1.moveTo(x/2,y/2);//开始的基点
path1.lineTo(x/2,y/4);//最后的基点
canvas.drawPath(path1,paint);
canvas.restore();
//分针
paint.setColor(R.color.MediumSlateBlue);
canvas.save();
canvas.rotate(m,x/2,y/2);//旋转画布
Pathpath2=newPath();
path2.moveTo(x/2,y/2);//开始的基点
path2.lineTo(x/2,y/6);//最后的基点
canvas.drawPath(path2,paint);
canvas.restore();
//秒针
paint.setColor(Color.BLUE);
canvas.save();
canvas.rotate(s,x/2,y/2);//旋转画布
Pathpath3=newPath();
path3.moveTo(x/2,y/2);//开始的基点
path3.lineTo(x/2,y/9);//最后的基点
canvas.drawPath(path3,paint);
canvas.restore();
}
publicvoiddrawDial(Canvascanvas,Paintpaint){
intx=310;
inty=x;
paint.setColor(Color.WHITE);
canvas.drawCircle(x/2,y/2,x/2-2,paint);
canvas.drawCircle(x/2,y/2,x/40,paint);
Pathpath9=newPath();//接下来的是，画时针的刻度
path9.moveTo(2,y/2);
path9.lineTo(y/18,y/2);
canvas.drawPath(path9,paint);
Pathpath12=newPath();
path12.moveTo(x/2,2);
path12.lineTo(x/2,y/18);
canvas.drawPath(path12,paint);
Pathpath3=newPath();
path3.moveTo(x-2,y/2);
path3.lineTo(x-x/18,y/2);
canvas.drawPath(path3,paint);
Pathpath6=newPath();
path6.moveTo(x/2,y-2);
path6.lineTo(x/2,y-y/18);
canvas.drawPath(path6,paint);
canvas.save();
canvas.rotate(32,x/2,y/2);
Pathpath10=newPath();
path10.moveTo(2,y/2);
path10.lineTo(x/32,y/2);
canvas.drawPath(path10,paint);
Pathpath1=newPath();
path1.moveTo(x/2,2);
path1.lineTo(x/2,y/32);
canvas.drawPath(path1,paint);
Pathpath4=newPath();
path4.moveTo(x-1,y/2);
path4.lineTo(x-x/32,y/2);
canvas.drawPath(path4,paint);
Pathpath7=newPath();
path7.moveTo(x/2,y-2);
path7.lineTo(x/2,y-y/32);
canvas.drawPath(path7,paint);
canvas.restore();
canvas.save();
canvas.rotate(60,x/2,y/2);
Pathpath11=newPath();
path11.moveTo(2,y/2);
path11.lineTo(x/32,y/2);
canvas.drawPath(path11,paint);
Pathpath2=newPath();
path2.moveTo(x/2,2);
path2.lineTo(x/2,y/32);
canvas.drawPath(path2,paint);
Pathpath5=newPath();
path5.moveTo(x-2,y/2);
path5.lineTo(x-x/32,y/2);
canvas.drawPath(path5,paint);
Pathpath8=newPath();
path8.moveTo(x/2,y-2);
path8.lineTo(x/2,y-y/32);
canvas.drawPath(path8,paint);
canvas.restore();
}
}