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();
}
}