此节简单写下Object－C中对于调试打印的常用语句：
简单类型的定义如下：
以上代码有两种基本类型不同：
第一是布尔值，在Object－C种使用 BOOL 来进行声明；
第二：字符串的定义使用NSString，大家知道字符串是类类型，显然在Object这种类c语言声明其对象则采用＊指针，对于指针概念不是很了解请“度娘”之～
然后打印语句则使用［NSLog（@""）］语句，如下：
打印的方式都是通过％＋？的形式来表示打印的类型，从以上两小段代码种可以看到，在ObjectC中，字符串常量是由@符号与一对""双引号括起的字符序列，字符串打印使用％@；
全部代码：
研究了一下Xcode 发现，在Edit－Format－Re Indent 则是让代码重新排版～～
OpenGL给正方体的各个面加上纹理（贴图）
注意事项：
*图片如果放在drawable-mdpi目录下，则在模拟器上可以正常显示，但是在真机上不能显示图片，本处新建一个drawable-nodpi目录，将图片资源放在此目录下
1.代码
import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLSurfaceView;
import android.os.Bundle;
public class OpenGLActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Bitmap bm1 = BitmapFactory.decodeResource(getResources(), R.drawable.a1);
Bitmap bm2 = BitmapFactory.decodeResource(getResources(), R.drawable.a2);
Bitmap bm3 = BitmapFactory.decodeResource(getResources(), R.drawable.a3);
Bitmap bm4 = BitmapFactory.decodeResource(getResources(), R.drawable.a4);
Bitmap bm5 = BitmapFactory.decodeResource(getResources(), R.drawable.a5);
Bitmap bm6 = BitmapFactory.decodeResource(getResources(), R.drawable.a6);
GLSurfaceView glView = new GLSurfaceView(this);
glView.setRenderer(new GLTextureRender(bm1, bm2, bm3, bm4, bm5, bm6));
setContentView(glView);
}
}
package com.lanhuidong.opengl;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import com.lanhuidong.opengl.util.BufferToNativeOrder;
import android.graphics.Bitmap;
import android.opengl.GLSurfaceView.Renderer;
import android.opengl.GLUtils;
public class GLTextureRender implements Renderer
{
float xrot, yrot, zrot;
int texture[];
int one = 0x10000;
int[] vertices = new int[]{
-one,-one,one, //前
one,-one,one,
one,one,one,
-one,one,one,
-one,-one,-one, //后
-one,one,-one,
one,one,-one,
one,-one,-one,
-one,one,-one, //上
-one,one,one,
one,one,one,
one,one,-one,
-one,-one,-one, //下
one,-one,-one,
one,-one,one,
-one,-one,one,
-one,-one,-one, //左
-one,-one,one,
-one,one,one,
-one,one,-one,
one,-one,-one, //右
one,one,-one,
one,one,one,
one,-one,one,
};
int[] texCoords = new int[]{
one,one,one,0,0,0,0,one,
0,0,0,one,one,one,one,0,
one,one,one,0,0,0,0,one,
0,one,one,one,one,0,0,0,
0,0,0,one,one,one,one,0,
one,0,0,0,0,one,one,one,
};
ByteBuffer indices1 = ByteBuffer.wrap(new byte[]{
0,1,3,2,
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
});
ByteBuffer indices2 = ByteBuffer.wrap(new byte[]{
0,0,0,0,
4,5,7,6,
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0
});
ByteBuffer indices3 = ByteBuffer.wrap(new byte[]{
0,0,0,0,
0,0,0,0,
8,9,11,10,
0,0,0,0,
0,0,0,0,
0,0,0,0
});
ByteBuffer indices4 = ByteBuffer.wrap(new byte[]{
0,0,0,0,
0,0,0,0,
0,0,0,0,
12,13,15,14,
0,0,0,0,
0,0,0,0
});
ByteBuffer indices5 = ByteBuffer.wrap(new byte[]{
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
16,17,19,18,
0,0,0,0
});
ByteBuffer indices6 = ByteBuffer.wrap(new byte[]{
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0,
20,21,23,22,
});
private Bitmap bm1;
private Bitmap bm2;
private Bitmap bm3;
private Bitmap bm4;
private Bitmap bm5;
private Bitmap bm6;
public GLTextureRender(Bitmap bm1, Bitmap bm2,Bitmap bm3, Bitmap bm4,Bitmap bm5, Bitmap bm6){
this.bm1 = bm1;
this.bm2 = bm2;
this.bm3 = bm3;
this.bm4 = bm4;
this.bm5 = bm5;
this.bm6 = bm6;
}
@Override
public void onDrawFrame(GL10 gl)
{
gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity();
gl.glTranslatef(0.0f, 0.0f, -5.0f);
gl.glRotatef(xrot, 1.0f, 0.0f, 0.0f);
gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);
gl.glRotatef(zrot, 0.0f, 0.0f, 1.0f);
gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
gl.glVertexPointer(3, GL10.GL_FIXED, 0, BufferToNativeOrder.getNativeOrderIntBuffer(vertices));
gl.glTexCoordPointer(2, GL10.GL_FIXED, 0, BufferToNativeOrder.getNativeOrderIntBuffer(texCoords));
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[0]);
gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, 24, GL10.GL_UNSIGNED_BYTE, indices1);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[1]);
gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, 24, GL10.GL_UNSIGNED_BYTE, indices2);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[2]);
gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, 24, GL10.GL_UNSIGNED_BYTE, indices3);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[3]);
gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, 24, GL10.GL_UNSIGNED_BYTE, indices4);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[4]);
gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, 24, GL10.GL_UNSIGNED_BYTE, indices5);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[5]);
gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, 24, GL10.GL_UNSIGNED_BYTE, indices6);
gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
xrot+=1f;
yrot+=1.2f;
zrot+=0.6f;
}
@Override
public void onSurfaceChanged(GL10 gl, int width, int height)
{
float ratio = (float) width / height;
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL10.GL_PROJECTION);
gl.glLoadIdentity();
gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
gl.glMatrixMode(GL10.GL_MODELVIEW);
gl.glLoadIdentity();
}
@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config)
{
gl.glClearColor(1, 1, 1, 1);
gl.glEnable(GL10.GL_CULL_FACE);
gl.glShadeModel(GL10.GL_SMOOTH);
gl.glEnable(GL10.GL_DEPTH_TEST);
gl.glClearDepthf(1.0f);
gl.glDepthFunc(GL10.GL_LEQUAL);
gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);
gl.glEnable(GL10.GL_TEXTURE_2D);
IntBuffer intBuffer = IntBuffer.allocate(6);
gl.glGenTextures(6, intBuffer);
texture = intBuffer.array();
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[0]);
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bm1, 0);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[1]);
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bm2, 0);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[2]);
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bm3, 0);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[3]);
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bm4, 0);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[4]);
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bm5, 0);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
gl.glBindTexture(GL10.GL_TEXTURE_2D, texture[5]);
GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bm6, 0);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
}
}
2.效果
转载http://blog.csdn.net/liutao5757124/article/details/6064099
本文通过对Android内置闹铃功能的简单介绍，来让开发者朋友们了解基于OPhone平台下客户/服务模式的编程模型，以及如何使用OPhone 系统提供的闹铃唤醒功能。与此同时，本文还对PendingIntent做一些简单的介绍，并通过实例程序来演示如何通过PendingIntent将闹 钟应用程序和系统闹铃服务联系起来。
一、闹铃功能
闹钟应用程序作为人 们日常常用的基本应用程序之一，其重要性不言而喻。在OPhone系统中闹铃服务功能不仅仅对闹钟应用程序服务，最重要的是可以利用该闹铃服务功能提供的 唤醒能力来做定时器。这样即便应用程序没有运行或者是没有启动的情况下，只要其注册过闹铃，那么该闹铃到时间后，OPhone系统可以自动将该应用程序启 动，这就是所谓的闹铃“唤醒“功能。
在OPhone系统中，底层系统提供了两种类型的时钟，软时钟与硬时钟，软时钟就是我们常说的 Timer,硬时钟就是RTC。系统在正常运行的情况下，Timer工作提供时间服务和闹铃提醒，而在系统进入睡眠状态后，时间服务和闹铃提醒由RTC来 负责。对于上层应用来说，我们并不需要关心是 timer还是RTC为我们提供服务，因为OPhone系统的Framework层把底层细节做了封装并统一提供API。这个API他的名字就叫 AlarmManager。在OPhone系统中有意思的是对应AlarmManage有一个AlarmManagerServie服务程序，该服务程序 才是正真提供闹铃服务的，它主要维护应用程序注册下来的各类闹铃并适时的设置即将触发的闹铃给闹铃设备(在OPhone系统中，linux实现的设备名为 ”/dev/alarm”)，并且一直监听闹铃设备，一旦有闹铃触发或者是闹铃事件发生，AlarmManagerServie服务程序就会遍历闹铃列表 找到相应的注册闹铃并发出广播。该服务程序在系统启动时被系统服务程序system_service启动并初始化闹铃设备(/dev/alarm)。当 然，在Java层的AlarmManagerService与Linux Alarm驱动 程序接口之间还有一层封装，那就是JNI。
AlarmManager将应用与服务分割开来后，使得应用程序开发者不用关心具体的服务，而是直接通过AlarmManager来使用这种服务。这也 许就是客户/服务模式的好处吧。AlarmManager与AlarmManagerServie之间是通过Binder来通信 的，他们之间是多对一的关系。在OPhone系统中，AlarmManage 提供了3个接口5种类型的闹铃服务：
- 3个API调用接口：
void cancel(PendingIntent operation)
// 取消已经注册的与参数匹配的闹铃
void set ( int type, long triggerAtTime, PendingIntent operation)
// 注册一个新的闹铃
void setRepeating( int type, long triggerAtTime, long interval, PendingIntent operation)
// 注册一个重复类型的闹铃
void setTimeZone( String timeZone)
// 设置时区 - 5种闹铃类型：
public static final int ELAPSED_REALTIME
// 当 系统进入睡眠状态时，这种类型的闹铃不会唤醒系统。直到系统下次被唤醒才传递它，该闹铃所用的时间是相对时间，是从系统启动后开始计时的,包括睡眠时间， 可以通过调用SystemClock.elapsedRealtime()获得。系统值是3 (0x00000003)。
public static final int ELAPSED_REALTIME_WAKEUP
// 能唤醒系统，用法同ELAPSED_REALTIME，系统值是2 (0x00000002) 。
public static final int RTC
// 当系统进入睡眠状态时，这种类型的闹铃不会唤醒系统。直到系统下次被唤醒才传递它，该闹铃所用的时间是绝对时间，所用时间是UTC时间，可以通过调用 System.currentTimeMillis()获得。系统值是1 (0x00000001) 。
public static final int RTC_WAKEUP
// 能唤醒系统，用法同RTC类型，系统值为 0 (0x00000000) 。
Public static final int POWER_OFF_WAKEUP
// 能唤醒系统，它是一种关机闹铃，就是说设备在关机状态下也可以唤醒系统，所以我们把它称之为关机闹铃。使用方法同RTC类型，系统值为4(0x00000004)。
开发者可以通过OPhone SDK来获取更多AlarmManager的相关细节，他所在的包是：Android.app.AlarmManager
随着OPhone系统版本的不断的升级，这些接口和闹铃类型也许会有些调整，但其基本使用方法将不会改变
二、闹钟设置与提醒
我们首先通过一个直观的UI来感受一下OPhone系统内嵌的闹钟程序是如何响应用户设置和自动提醒的的：(如下4个图所示)
上面4图直观的告诉了开发者如何使用OPhone内嵌的闹钟应用程序，但开发者可能更关心的是通过代码如何实现这些功能。比如说怎么设置一个闹铃，该设置哪种类型的闹铃，以及如何获得闹铃时间已到并提醒用户。依据这几个问题，我们在下面的章节中逐步来介绍。
2.1 设置闹铃
在第一小节中，我们已经提到过OPhone系统AlarmManagerService提供了两个设置闹铃的API，他们分别是：
void setRepeating( int type, long triggerAtTime, long interval, PendingIntent operation)
在OPhone 1.5版本中又增加了一个API。
下面的程序演示了如何设置一个闹铃。
// 时注册一个闹铃事件接收对象AlarmReceiver ，该接收对象也可以通过在 // AndroidManifest.xml中发布，也可以在代码中动态注册。
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.SystemClock;
import android.os.Bundle;
import java.util.Calendar;
// 创建一个PendingIntent
Intent intent = new Intent(ALARM_ALERT_ACTION);
intent.putExtra(ID, id);
intent.putExtra( TIME , atTimeInMillis);
PendingIntent sender = PendingIntent.getBroadcast(
context, 0 , intent, PendingIntent.FLAG_CANCEL_CURRENT);
// 获得AlarmMnager并注册一个新闹铃，
// 一次性闹铃的设置
AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);
am.set(AlarmManager.POWER_OFF_WAKEUP, atTimeInMillis, sender);
// 重复性闹铃的设置
// We want the alarm to go off 30 seconds from now .
long firstTime = SystemClock.elapsedRealtime();
firstTime += 15 * 1000 ;
// Schedule the alarm!
AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);
am.setRepeating(AlarmManager.POWER_OFF_WAKEUP,
firstTime, 15 * 1000 , sender);
< receiver android:name = " AlarmReceiver " >
< intent - filter >
< action android:name = " com.android.alarmclock.ALARM_ALERT " />
</ intent - filter >
</ receiver >
AlarmReceiver mAlarmReceiver;
IntentFilter filter = new IntentFilter();
filter .addAction(“com.android.alarmclock.ALARM_ALERT”);
context.registerReceiver(mAlarmReceiver, filter );
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
}
}
在OPhone系统中，当应用程序所设置的闹铃时间到了后，OPhone系统中的 AlarmManagerService就会从系统底层获取一个闹铃事件并从自己维护的队列中取出其匹配的闹铃，然后通过其应用注册的 PendingIntent把该闹铃事件发送回给应用。
当我们的应用收到该Intent后就会启动相应的Activity来提醒用户闹铃时间到。
程序代码如下：
import android.content.Context;
import android.content.Intent;
import android.content.BroadcastReceiver;
import android.os.Handler;
import android.os.PowerManager;
import android.os.SystemClock;
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
long now = System.currentTimeMillis();
int id = intent.getIntExtra(Alarms.ID, 0 );
long setFor = intent.getLongExtra(Alarms.TIME, 0 );
Intent fireAlarm = new Intent(context, AlarmAlert.class);
fireAlarm.putExtra(Alarms.ID, id);
fireAlarm.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 启动一个新的UI对象来提醒
context.startActivity(fireAlarm);
}
}
在前面的章节中，我们在注册闹铃﹑发送闹铃事件的时候，有过一个重要的参数 PendingIntent。这个PendingIntent可以说是 Intent的进一步封装，他既包含了Intent的描述又是Intent行为的执行(这种定义也许不太严格)，如果将Intent比作成一个订单的 话，PendingIntent更像是一个下订单的人，因为它既要负责将订单发出去，也要负责订单发送后的处理，比如发送成功后要准备验收订单货物，发送 失败后要重发还是取消订单等操作。开发者可以通过调用getActivity(Context, int, Intent, int), getBroadcast(Context, int, Intent, int), getService(Context, int, Intent, int)函数来得到一个PendingIntent实例。
通过该函数获得的PendingIntent将会扮演一个广播的功能，就像调用 Context.sendBroadcast()函数一样。当系统通过它要发送一个intent时要采用广播的形式，并且在该intent中会包含相应的 intent接收对象，当然这个对象我们可以在创建PendingIntent的时候指定，也可以通过ACTION 和CATEGORY等描述让OPhone系统自动找到该行为处理对象。
实例代码如下：
PendingIntent sender = PendingIntent.getBroadcast(AlarmController.this,
0 , intent, 0 );
通过该函数获得的PendingIntent可以直接启动新的activity, 就像调用 Context.startActivity(Intent)一样.不过值得注意的是要想这个新的Activity不再是当前进程存在的Activity 时。我们在intent中必须使用Intent.FLAG_ACTIVITY_NEW_TASK.
实例代码如下：
PendingIntent contentIntent = PendingIntent.getActivity(this, 0 ,
new Intent(this, AlarmService.class), 0 );
通过该函数获得的PengdingIntent可以直接启动新的Service，就像调用Context.startService()一样。
实例代码如下：
// with the alarm manager.
mAlarmSender = PendingIntent.getService(AlarmService.this,
0 , new Intent(AlarmService.this, AlarmService_Service.class), 0 );
四、PendingInent与 service
在OPhone系统编程中，一个完整OPhone应用程序可以有4个需要创建的模块，他们分别是：
Activity ,Broadcast intent Receiver,Service,Content Provider。Service作为一个OPhone应用程序组成部分，通常运行在系统后台，他与用户之间没有交互。像其他应用程序对象一样运行在所属 进程的主线程中。那么这就意味着它有可能进入长时间的运行等待而导致应用得不到用户的相应。所以在开发者设计程序的时候就要考虑，如果一个Service 要做一些长时间的数据处理时(比如播放MP3 ，或者是网络 下载),就需要把该工作切换到自己的线程空间来执行。
实例代码如下：
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
import android.widget.Toast;
// 定义一个 Service 对象
public class AlarmService_Service extends Service {
NotificationManager mNM;
public void onCreate() {
// 创建一个线程来运行Runnable
Thread thr = new Thread( null , mTask, " AlarmService_Service " );
thr.start();
}
public void onDestroy() {
}
Runnable mTask = new Runnable() {
public void run() {
// 通常我们就可以在这里设计长时间运行的功能，
long endTime = System.currentTimeMillis() + 15 * 1000 ;
while (System.currentTimeMillis() < endTime) {
synchronized (mBinder) {
try {
mBinder.wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
// 停止Service
AlarmService_Service.this.stopSelf();
}
};
// 在编写Service代码时，可以不实现onStart,onStop等函数，但一定要实现onBind函数
public IBinder onBind(Intent intent) {
return mBinder;
}
/* 通过该对象可以与客户端通信
*/
private final IBinder mBinder = new Binder() {
@Override
protected boolean onTransact( int code, Parcel data, Parcel reply,
int flags) throws RemoteException {
return super.onTransact(code, data, reply, flags);
}
};
}
小结: 本 篇文章主要介绍了如何使用AlarmManager的定时唤醒功能，以及各种闹铃的含义与API使用实例，希望对读者朋友们在OPhone应用编程中，对 AlarmManager的正确使用起到抛砖引玉的作用。同时我们还引入了一个重要的概念 PendingIntent,通过对PendingIntent参数的解析，相信读者朋友们对PendingIntent的使用有了一个基本的认识。