Darren Yuen

suspend fun main() {  
	withContext(Dispatchers.IO) {  
		val result = async { getResult() }.await()  
		println("result=$result")  
	}  
}  
  
suspend fun getResult() = suspendCoroutine<Boolean> {  
	val callback = object : Callback {  
		override fun onSuccess() {  
			it.resume(true)  
		}  
	  
		override fun onFail() {  
			it.resumeWithException(Exception("fail"))  
		}  
	  
		override fun onCancel() {  
			it.resume(false)  
		}  
	}  
	handleCallback(callback)  
}  
  
fun handleCallback(callback: Callback) {  
	callback.onFail()  
}  
  
interface Callback {  
	fun onSuccess()  
	fun onFail()  
	fun onCancel()  
}

// 自定义的可取消挂起函数  
suspend fun customCancelableOperation(): String {  
	return suspendCancellableCoroutine { continuation ->  
		val job = GlobalScope.launch {  
			try {  
				// 模拟异步操作  
				delay(1000)  
				// 如果操作成功，恢复挂起操作并传递结果  
				continuation.resume("Operation completed successfully")  
			} catch (e: CancellationException) {  
				// 如果操作被取消，处理取消操作  
				continuation.resumeWithException(e)  
			} catch (e: Exception) {  
				// 如果操作失败，传递异常  
				continuation.resumeWithException(e)  
			}  
		}  
		  
		// 当外部协程取消时，取消内部协程  
		continuation.invokeOnCancellation {  
		job.cancel()  
		}  
	}  
}  
  
fun main() = runBlocking {  
	val job = launch {  
		val result = customCancelableOperation()  
		println(result)  
	}  
	  
	delay(500) // 等待一段时间  
	job.cancel() // 取消外部协程  
	job.join()  
}

fun main() = runBlocking {  
	val exceptionHandler = CoroutineExceptionHandler { _, exception ->  
		println("Caught exception: $exception")  
	}  
	  
	val job = GlobalScope.launch(exceptionHandler) {  
		println(data)  
	}  
	  
	job.join()  
}

fun <T> Continuation<T>.safeResume(value: T) {  
	if (this is CancellableContinuation) {  
		if (isActive) {  
			resume(value)  
		} else {  
			CapaLog.d("Continuation", "continuation is not active")  
		}  
	} else throw Exception("Must use suspendCancellableCoroutine instead of suspendCoroutine")  
}

/**  
* Handle system messages here.  
*/  
public void dispatchMessage(@NonNull Message msg) {  
	if (msg.callback != null) {  
		handleCallback(msg);  
	} else {  
		if (mCallback != null) {  
			if (mCallback.handleMessage(msg)) {  
				return;  
			}  
		}  
		handleMessage(msg);  
	}  
}

boolean enqueueMessage(Message msg, long when) {  
	if (msg.target == null) {  
		throw new IllegalArgumentException("Message must have a target.");  
	}  
	// 因为可能在任意对象操作入队，而只会在looper所绑定的线程出队，所以这里加对象锁，保证入队出队操作是线程安全的
	synchronized (this) {  
		if (msg.isInUse()) {  
			throw new IllegalStateException(msg + " This message is already in use.");  
		}  
		  
		if (mQuitting) {  
			IllegalStateException e = new IllegalStateException(  
			msg.target + " sending message to a Handler on a dead thread");  
			Log.w(TAG, e.getMessage(), e);  
			msg.recycle();  
			return false;  
		}  
		  
		msg.markInUse();  
		msg.when = when;  
		Message p = mMessages;  
		boolean needWake;  
		if (p == null || when == 0 || when < p.when) {  
			// New head, wake up the event queue if blocked.
			// 当前队列为空  
			msg.next = p;  
			mMessages = msg;  
			needWake = mBlocked;
		} else {  
			// Inserted within the middle of the queue. Usually we don't have to wake  
			// up the event queue unless there is a barrier at the head of the queue  
			// and the message is the earliest asynchronous message in the queue.  
			needWake = mBlocked && p.target == null && msg.isAsynchronous();  
			Message prev; 
			// 按调度时间调整队列位置 
			for (;;) {  
				prev = p;  
				p = p.next;  
				if (p == null || when < p.when) {  
					break;  
				}  
				if (needWake && p.isAsynchronous()) {  
					needWake = false;  
				}  
			}  
			msg.next = p; // invariant: p == prev.next  
			prev.next = msg;  
		}  
			  
		// We can assume mPtr != 0 because mQuitting is false.  
		if (needWake) {  
			nativeWake(mPtr);  
		}  
	}  
	return true;  
}

Message next() {  
	// Return here if the message loop has already quit and been disposed.  
	// This can happen if the application tries to restart a looper after quit  
	// which is not supported.  
	final long ptr = mPtr;  
	if (ptr == 0) {  
		return null;  
	}  
	  
	int pendingIdleHandlerCount = -1; // -1 only during first iteration  
	int nextPollTimeoutMillis = 0;  
	for (;;) {  
		if (nextPollTimeoutMillis != 0) {  
		Binder.flushPendingCommands();  
	}  
	  
	nativePollOnce(ptr, nextPollTimeoutMillis);  // 用来检查消息队列中是否有新的消息要处理，当队列为空时，`nativePollOnce` 会使线程等待直到：1. 有新消息到达。2. 被唤醒去处理其他任务（例如，定时事件、输入事件等）。3. 明确使用 `wakeUp()` 方法唤醒。
	  
	synchronized (this) {  
		// Try to retrieve the next message. Return if found.  
		final long now = SystemClock.uptimeMillis();  
		Message prevMsg = null;  
		Message msg = mMessages;  
		if (msg != null && msg.target == null) {  
			// Stalled by a barrier. Find the next asynchronous message in the queue.  
			do {  
				prevMsg = msg;  
				msg = msg.next;  
			} while (msg != null && !msg.isAsynchronous());  
		}  
		if (msg != null) {  
			if (now < msg.when) {  
				// Next message is not ready. Set a timeout to wake up when it is ready.  
				nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);  
			} else {  
				// Got a message.  
				mBlocked = false;  
				if (prevMsg != null) {  
					prevMsg.next = msg.next;  
				} else {  
					mMessages = msg.next;  
				}  
				msg.next = null;  
				if (DEBUG) Log.v(TAG, "Returning message: " + msg);  
				msg.markInUse();  
				return msg;  
			}  
		} else {  
			// No more messages.  
			nextPollTimeoutMillis = -1;  
		}  
		  
		// Process the quit message now that all pending messages have been handled.  
		if (mQuitting) {  
			dispose();  
			return null;  
		}  
		  
		// If first time idle, then get the number of idlers to run.  
		// Idle handles only run if the queue is empty or if the first message  
		// in the queue (possibly a barrier) is due to be handled in the future.  
		if (pendingIdleHandlerCount < 0  
			&& (mMessages == null || now < mMessages.when)) {  
			pendingIdleHandlerCount = mIdleHandlers.size();  
		}  
		if (pendingIdleHandlerCount <= 0) {  
			// No idle handlers to run. Loop and wait some more.  
			mBlocked = true;  // 没有消息，休眠
			continue;  
		}  
		  
		if (mPendingIdleHandlers == null) {  
			mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];  
		}  
		mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);  
		}  
		  
		// Run the idle handlers.  
		// We only ever reach this code block during the first iteration.  
		for (int i = 0; i < pendingIdleHandlerCount; i++) {  
			final IdleHandler idler = mPendingIdleHandlers[i];  
			mPendingIdleHandlers[i] = null; // release the reference to the handler  
			  
			boolean keep = false;  
			try {  
			keep = idler.queueIdle();  
			} catch (Throwable t) {  
			Log.wtf(TAG, "IdleHandler threw exception", t);  
			}  
			  
			if (!keep) {  
			synchronized (this) {  
			mIdleHandlers.remove(idler);  
			}  
		}  
		}  
		  
		// Reset the idle handler count to 0 so we do not run them again.  
		pendingIdleHandlerCount = 0;  
		  
		// While calling an idle handler, a new message could have been delivered  
		// so go back and look again for a pending message without waiting.  
		nextPollTimeoutMillis = 0;  
	}  
}

private static boolean loopOnce(final Looper me,  
final long ident, final int thresholdOverride) {  
	Message msg = me.mQueue.next(); // might block  
	if (msg == null) {  
		// No message indicates that the message queue is quitting.  
		return false;  
	}  
  
	// This must be in a local variable, in case a UI event sets the logger  
	final Printer logging = me.mLogging;  
	if (logging != null) {  
		logging.println(">>>>> Dispatching to " + msg.target + " "  
		+ msg.callback + ": " + msg.what);  
	}  
	// Make sure the observer won't change while processing a transaction.  
	final Observer observer = sObserver;  
	  
	final long traceTag = me.mTraceTag;  
	long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;  
	long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;  
	if (thresholdOverride > 0) {  
		slowDispatchThresholdMs = thresholdOverride;  
		slowDeliveryThresholdMs = thresholdOverride;  
	}  
	final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);  
	final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);  
	  
	final boolean needStartTime = logSlowDelivery || logSlowDispatch;  
	final boolean needEndTime = logSlowDispatch;  
		  
	if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {  
		Trace.traceBegin(traceTag, msg.target.getTraceName(msg));  
	}  
	  
	final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;  
	final long dispatchEnd;  
	Object token = null;  
	if (observer != null) {  
		token = observer.messageDispatchStarting();  
	}  
	long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);  
	try {  
		msg.target.dispatchMessage(msg);  
		if (observer != null) {  
			observer.messageDispatched(token, msg);  
		}  
		dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;  
	} catch (Exception exception) {  
		if (observer != null) {  
			observer.dispatchingThrewException(token, msg, exception);  
		}  
		throw exception;  
	} finally {  
		ThreadLocalWorkSource.restore(origWorkSource);  
		if (traceTag != 0) {  
			Trace.traceEnd(traceTag);  
		}  
	}  
	if (logSlowDelivery) {  
		if (me.mSlowDeliveryDetected) {  
			if ((dispatchStart - msg.when) <= 10) {  
				Slog.w(TAG, "Drained");  
				me.mSlowDeliveryDetected = false;  
			}  
		} else {  
			if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",  
			msg)) {  
				// Once we write a slow delivery log, suppress until the queue drains.  
				me.mSlowDeliveryDetected = true;  
			}  
		}  
	}  
	if (logSlowDispatch) {  
		showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);  
	}  
	  
	if (logging != null) {  
		logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  
	}  
	  
	// Make sure that during the course of dispatching the  
	// identity of the thread wasn't corrupted.  
	final long newIdent = Binder.clearCallingIdentity();  
	if (ident != newIdent) {  
		Log.wtf(TAG, "Thread identity changed from 0x"  
		+ Long.toHexString(ident) + " to 0x"  
		+ Long.toHexString(newIdent) + " while dispatching to "  
		+ msg.target.getClass().getName() + " "  
		+ msg.callback + " what=" + msg.what);  
	}  
	  
	msg.recycleUnchecked();  
	  
	return true;  
}  
  
/**  
* Run the message queue in this thread. Be sure to call  
* {@link #quit()} to end the loop.  
*/  
@SuppressWarnings("AndroidFrameworkBinderIdentity")  
public static void loop() {  
	final Looper me = myLooper();  
	if (me == null) {  
		throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  
	}  
	if (me.mInLoop) {  
		Slog.w(TAG, "Loop again would have the queued messages be executed"  
		+ " before this one completed.");  
	}  
	  
	me.mInLoop = true;  
	  
	// Make sure the identity of this thread is that of the local process,  
	// and keep track of what that identity token actually is.  
	Binder.clearCallingIdentity();  
	final long ident = Binder.clearCallingIdentity();  
	  
	// Allow overriding a threshold with a system prop. e.g.  
	// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'  
	final int thresholdOverride =  
	SystemProperties.getInt("log.looper."  
	+ Process.myUid() + "."  
	+ Thread.currentThread().getName()  
	+ ".slow", 0);  
	  
	me.mSlowDeliveryDetected = false;  
	  
	for (;;) {  
		if (!loopOnce(me, ident, thresholdOverride)) {  
			return;  
		}  
	}  
}

public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {  
	synchronized (mConstructorArgs) {  

	View result = root;  
	  
	try {  
		advanceToRootNode(parser);  
		final String name = parser.getName();  
		  
		if (TAG_MERGE.equals(name)) {
		// merge标签处理  
			if (root == null || !attachToRoot) {  
				throw new InflateException("<merge /> can be used only with a valid "  
			+ "ViewGroup root and attachToRoot=true");  
			}  
		  
			rInflate(parser, root, inflaterContext, attrs, false);  
		} else {  
			// Temp is the root view that was found in the xml  
			final View temp = createViewFromTag(root, name, inflaterContext, attrs);  
			  
			ViewGroup.LayoutParams params = null;  
			  
			if (root != null) {  
				// Create layout params that match root, if supplied  
				params = root.generateLayoutParams(attrs);  
				if (!attachToRoot) {  
					// Set the layout params for temp if we are not  
					// attaching. (If we are, we use addView, below)  
					temp.setLayoutParams(params);  
				}
			} 
			  
			// Inflate all children under temp against its context.  
			rInflateChildren(parser, temp, attrs, true);  
			  
			// We are supposed to attach all the views we found (int temp)  
			// to root. Do that now.  
			if (root != null && attachToRoot) {  
				root.addView(temp, params);  
			}  
			  
			// Decide whether to return the root that was passed in or the  
			// top view found in xml.  
			if (root == null || !attachToRoot) {  
				result = temp;  
			}  
		}  
	  
	} catch (XmlPullParserException e) {  

	} catch (Exception e) {  

	} finally {  
		// Don't retain static reference on context.  
		
	}  
	  
	return result;  
	}  
}

class Box<T : Number>(val value: T)  // T 的上界是 Number，所以只能接受数字类型

fun printValue(value: Any) {  // 只接受非空的任何值
	println(value)
}

fun printValue(value: Any?) {  // 可以接受任何值，包括 null
    println(value)
}

fun <T> isString(value: T): Boolean {
   return value is String  // 会出现类型擦除的问题，此处 is String 仍然会编译通过但有警告
}
 
fun isString(value: Any): Boolean {
   return value is String  // 不会被类型擦除，运行时仍然有效
}

class Container<T>(val content: T) {
	fun getContent(): T = content
}

fun <T> createContainer(item: T): Container<T> {
	return Container(item)
}

interface Source<out T> {
    fun nextT(): T
}

fun demo(source: Source<String>) {
    val anySource: Source<Any> = source // 协变，String 是 Any 的子类型，所以 Source<String> 可以赋值给 Source<Any>
}

interface Consumer<in T> {
    fun consume(item: T)
}

fun demo(consumer: Consumer<Number>) {
    val intConsumer: Consumer<Int> = consumer // 逆变，Int 是 Number 的子类型，所以 Consumer<Number> 可以赋值给 Consumer<Int>
}

// 定义一个具有上界的泛型类
class Box<T : Number>(val value: T)

fun <T : Number> sum(value1: T, value2: T): Double {
    return value1.toDouble() + value2.toDouble()
}

// 定义一个协变接口
interface Source<out T> {
    fun nextT(): T
}

// 定义一个逆变接口
interface Consumer<in T> {
    fun consume(item: T)
}

fun main() {
    // 使用具有上界的泛型类
    val intBox = Box(1)
    val doubleBox = Box(1.0)

    println(sum(1, 2))         // 输出: 3.0
    println(sum(1.0, 2.0))     // 输出: 3.0

    // 示例协变
    val stringSource: Source<String> = object : Source<String> {
        override fun nextT(): String {
            return "Hello"
        }
    }
    val anySource: Source<Any> = stringSource
    println(anySource.nextT())  // 输出: Hello

    // 示例逆变
    val numberConsumer: Consumer<Number> = object : Consumer<Number> {
        override fun consume(item: Number) {
            println("Consumed $item")
        }
    }
    val intConsumer: Consumer<Int> = numberConsumer
    intConsumer.consume(10)  // 输出: Consumed 10
}

val filePath = "dir/${System.currentTimeMillis()}.pb"  
var outputStream: FileOutputStream? = null
try {  
	val demoParam = addressBookBuilder.build()  
	FileUtils.createOrExistsFile(File(filePath))  
	outputStream = FileOutputStream(filePath)  
try {  
	demoParam.writeTo(outputStream)  
} catch (t: Throwable) {  
  
}  
} catch (t: Throwable) {  
 
} finally {  
	outputStream?.close()  
}