Scala Uri类代码示例

//设置package包名称以及导入依赖的类
package com.github.shadowsocks.plugin

import java.io.File

import android.database.MatrixCursor
import android.net.Uri


final class PathProvider private[plugin](baseUri: Uri, cursor: MatrixCursor) {
  private val basePath = baseUri.getPath match {
    case null => ""
    case p => p.stripPrefix("/").stripSuffix("/")
  }

  def addPath(path: String, mode: String = "644"): PathProvider = {
    val stripped = path.stripPrefix("/").stripSuffix("/")
    if (stripped.startsWith(basePath)) cursor.newRow()
      .add(PluginContract.COLUMN_PATH, stripped)
      .add(PluginContract.COLUMN_MODE, mode)
    this
  }
  def addTo(file: File, to: String = "", mode: String = "644"): PathProvider = {
    var sub = to + file.getName
    if (basePath.startsWith(sub)) if (file.isDirectory) {
      sub += '/'
      file.listFiles().foreach(addTo(_, sub, mode))
    } else addPath(sub, mode)
    this
  }
  def addAt(file: File, at: String = "", mode: String = "644"): PathProvider = {
    if (basePath.startsWith(at))
      if (file.isDirectory) file.listFiles().foreach(addTo(_, at, mode)) else addPath(at, mode)
    this
  }
} 

//设置package包名称以及导入依赖的类
package com.github.shadowsocks.plugin

import android.content.{ContentProvider, ContentValues}
import android.database.{Cursor, MatrixCursor}
import android.net.Uri
import android.os.{Bundle, ParcelFileDescriptor}


  def getExecutable: String = throw new UnsupportedOperationException

  def openFile(uri: Uri): ParcelFileDescriptor
  override def openFile(uri: Uri, mode: String): ParcelFileDescriptor = {
    assert(mode == "r")
    openFile(uri)
  }

  override def call(method: String, arg: String, extras: Bundle): Bundle = method match {
    case PluginContract.METHOD_GET_EXECUTABLE =>
      val out = new Bundle()
      out.putString(PluginContract.EXTRA_ENTRY, getExecutable)
      out
    case _ => super.call(method, arg, extras)
  }

  // Methods that should not be used
  override def update(uri: Uri, values: ContentValues, selection: String, selectionArgs: Array[String]): Int = ???
  override def insert(uri: Uri, values: ContentValues): Uri = ???
  override def delete(uri: Uri, selection: String, selectionArgs: Array[String]): Int = ???
} 

//设置package包名称以及导入依赖的类
package com.waz

import java.io.File
import java.util.concurrent.CountDownLatch

import android.content.Context
import android.net.Uri
import android.support.test.InstrumentationRegistry
import android.support.test.runner.AndroidJUnit4
import com.waz.api.AssetFactory.LoadCallback
import com.waz.api.{AssetFactory, AssetForUpload}
import com.waz.bitmap.video.VideoTranscoder
import com.waz.service.ZMessaging
import com.waz.threading.Threading
import org.junit.runner.RunWith
import org.junit.{Assert, Before, Test}

import scala.concurrent.Await
import scala.concurrent.duration._

@RunWith(classOf[AndroidJUnit4])
class VideoTranscoderTest {

  @Before def setUp(): Unit = {
    Threading.AssertsEnabled = false
    ZMessaging.onCreate(context)
  }

  @Test def audioTranscodingFrom8kHz(): Unit = {
    val transcoder = VideoTranscoder(context)
    val out = File.createTempFile("video", ".mp4", context.getCacheDir)

    val future = transcoder(Uri.parse("content://com.waz.test/8khz.mp4"), out, { _ => })

    Assert.assertEquals(out, Await.result(future, 15.seconds))
  }

  @Test def assetLoadingWithNoAudio(): Unit = {
    val latch = new CountDownLatch(1)
    var asset = Option.empty[AssetForUpload]

    AssetFactory.videoAsset(Uri.parse("content://com.waz.test/no_audio.mp4"), new LoadCallback {
      override def onLoaded(a: AssetForUpload): Unit = {
        asset = Some(a)
        latch.countDown()

      }
      override def onFailed(): Unit = {
        println(s"transcode failed")
        latch.countDown()
      }
    })

    latch.await()
    Assert.assertTrue(asset.isDefined)
  }

  def context: Context = instr.getTargetContext
  def instr = InstrumentationRegistry.getInstrumentation
} 

//设置package包名称以及导入依赖的类
package com.waz

import android.content.Context
import android.net.Uri
import android.support.test.InstrumentationRegistry
import android.support.test.runner.AndroidJUnit4
import com.waz.model.AssetMetaData
import com.waz.service.ZMessaging
import com.waz.threading.Threading
import com.waz.utils._
import org.junit.runner.RunWith
import org.junit.{Assert, Before, Test}

import scala.concurrent.Await
import scala.concurrent.duration._

@RunWith(classOf[AndroidJUnit4])
class AssetMetaDataTest {

  @Before def setUp(): Unit = {
    Threading.AssertsEnabled = false
    ZMessaging.onCreate(context)
  }

  @Test def testAudioDurationLoadingFromUri(): Unit = {
    val meta = Await.result(AssetMetaData.Audio(context, Uri.parse("content://com.waz.test/32kbps.m4a")), 5.seconds)

    Assert.assertEquals(309L, meta.fold2(0L, _.duration.getSeconds))
  }

  def context: Context = instr.getTargetContext
  def instr = InstrumentationRegistry.getInstrumentation
} 

//设置package包名称以及导入依赖的类
package name.ryanboder.maestroid

import java.io.File

import android.content.Context
import android.media.{MediaPlayer, PlaybackParams}
import android.net.Uri
import org.scaloid.common._


class MusicPlayer(context: Context) extends TagUtil {
  val audioFilePath = "/sdcard/Music/Maestroid.mp3"
  info("Playing " + audioFilePath)

  val audioFile = new File(audioFilePath)
  val player = MediaPlayer.create(context, Uri.fromFile(audioFile))

  def apply(gesture: Gesture): Unit = {
    gesture match {
      case t: Tempo => changeTempo(t)
      case v: Volume => changeVolume(v)
      case g: Gesture => error("Unknown gesture " + g)
    }
  }

  private def changeTempo(tempo: Tempo): Unit = {
    if (!player.isPlaying) {
      player.start()
    }
    info("Setting speed to " + tempo.beatsPerSecond)
    val params = new PlaybackParams()
    params.setSpeed(tempo.beatsPerSecond.toFloat)
    player.setPlaybackParams(params)
  }

  private def changeVolume(v: Volume): Unit = {
    if (!player.isPlaying)
      return
    info("Setting volume to " + v)
    player.setVolume(v.volume.toFloat, v.volume.toFloat)
  }
}