androidxstream

Ⅰ 如何获取 Android 设备的CPU核数，时钟频率以及内存大小

获取 CPU 核数
linux 中的设备都是以文件的形式存在，CPU 也不例外，因此 CPU 的文件个数就等价与核数。
Android 的 CPU 设备文件位于/sys/devices/system/cpu/目录，文件名的的格式为cpu\d+。
root@generic_x86_64:/sys/devices/system/cpu # ls cpu0 cpufreq
cpuidle
kernel_max
modalias
offline
online
possible
power
present
uevent
统计一下文件个数便可以获得 CPU 核数。
public static int getNumberOfCPUCores（） {
if （Build.VERSION.SDK_INT <= Build.VERSION_CODES.GINGERBREAD_MR1） {
// Gingerbread doesn't support giving a single application access to both cores, but a
// handful of devices （Atrix 4G and Droid X2 for example） were released with a al-core
// chipset and Gingerbread; that can let an app in the background run without impacting
// the foreground application. But for our purposes, it makes them single core.
return 1;
}
int cores;
try {
cores = new File（“/sys/devices/system/cpu/”）。listFiles（CPU_FILTER）。length;
} catch （SecurityException e） {
cores = DEVICEINFO_UNKNOWN;
} catch （NullPointerException e） {
cores = DEVICEINFO_UNKNOWN;
}
return cores;
}
private static final FileFilter CPU_FILTER = new FileFilter（） {
@Override
public boolean accept（File pathname） {
String path = pathname.getName（）；
//regex is slow, so checking char by char.
if （path.startsWith（“cpu”）） {
for （int i = 3; i < path.length（）； i++） {
if （path.charAt（i） < '0' path.charAt（i） > '9‘） {
return false;
}
}
return true;
}
return false;
}
};
获取时钟频率
获取时钟频率需要读取系统文件 -/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq或者/proc/cpuinfo。
Android 模拟器中并没有cpuinfo_max_freq文件，因此只能读取/proc/cpuinfo。
/proc/cpuinfo包含了很多 cpu 数据。
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 70
model name : Intel（R） Core（TM） i7-4770HQ CPU @ 2.20GHz
stepping : 1
cpu MHz : 0.000
cache size : 1024 KB
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 4
wp : yes
代码如下：
public static int getCPUMaxFreqKHz（） {
int maxFreq = DEVICEINFO_UNKNOWN;
try {
for （int i = 0; i < getNumberOfCPUCores（）； i++） {
String filename =
“/sys/devices/system/cpu/cpu” + i + “/cpufreq/cpuinfo_max_freq”;
File cpuInfoMaxFreqFile = new File（filename）；
if （cpuInfoMaxFreqFile.exists（）） {
byte[] buffer = new byte[128];
FileInputStream stream = new FileInputStream（cpuInfoMaxFreqFile）；
try {
stream.read（buffer）；
int endIndex = 0;
//Trim the first number out of the byte buffer.
while （buffer[endIndex] >= '0' && buffer[endIndex] <= '9'
&& endIndex < buffer.length） endIndex++;
String str = new String（buffer, 0, endIndex）；
Integer freqBound = Integer.parseInt（str）；
if （freqBound > maxFreq） maxFreq = freqBound;
} catch （NumberFormatException e） {
//Fall through and use /proc/cpuinfo.
} finally {
stream.close（）；
}
}
}
if （maxFreq == DEVICEINFO_UNKNOWN） {
FileInputStream stream = new FileInputStream（“/proc/cpuinfo”）；
try {
int freqBound = parseFileForValue（“cpu MHz”, stream）；
freqBound *= 1000; //MHz -> kHz
if （freqBound > maxFreq） maxFreq = freqBound;
} finally {
stream.close（）；
}
}
} catch （IOException e） {
maxFreq = DEVICEINFO_UNKNOWN; //Fall through and return unknown.
}
return maxFreq;
}
获取内存大小
如果 SDK 版本大于等于JELLY_BEAN，可以通过ActivityManager来获取内从大小。
ActivityManager.MemoryInfo memInfo = new ActivityManager.MemoryInfo（）；
ActivityManager am = （ActivityManager） c.getSystemService（Context.ACTIVITY_SERVICE）；
am.getMemoryInfo（memInfo）；
如果版本低于JELLY_BEAN，则只能读取系统文件了。
FileInputStream stream = new FileInputStream（“/proc/meminfo”）；
totalMem = parseFileForValue（“MemTotal”, stream）；
完整代码如下：
@TargetApi（Build.VERSION_CODES.JELLY_BEAN）
public static long getTotalMemory（Context c） {
// memInfo.totalMem not supported in pre-Jelly Bean APIs.
if （Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN） {
ActivityManager.MemoryInfo memInfo = new ActivityManager.MemoryInfo（）；
ActivityManager am = （ActivityManager） c.getSystemService（Context.ACTIVITY_SERVICE）；
am.getMemoryInfo（memInfo）；
if （memInfo != null） {
return memInfo.totalMem;
} else {
return DEVICEINFO_UNKNOWN;
}
} else {
long totalMem = DEVICEINFO_UNKNOWN;
try {
FileInputStream stream = new FileInputStream（“/proc/meminfo”）；
try {
totalMem = parseFileForValue（“MemTotal”, stream）；
totalMem *= 1024;
} finally {
stream.close（）；
}
} catch （IOException e） {
}
return totalMem;
}
}

Ⅱ Android 10（29）适配方案简要说明

Android 10（29）适配方案简要说明

1、根据Google官方文档说明，Android10引入了大量变更

官方文档： https://developer.android.google.cn/about/versions/10/highlights?hl=zh_cn

1.1、Android 10 中的隐私权变更

1.1.1重大隐私权变更

分区存储

针对外部存储的过滤视图，可提供对特定于应用的文件和媒体集合的访问权限 访问和共享外部存储中的文件的应用 使用特定于应用的目录和媒体集合目录

增强了用户对位置权限的控制力

仅限前台权限，可让用户更好地控制应用对设备位置信息的访问权限 在后台时请求访问用户位置信息的应用 确保在没有后台位置信息更新的情况下优雅降级

使用 Android 10 中引入的权限在后台获取位置信息

系统执行后台 Activity

针对从后台启动 Activity 实施了限制 不需要用户互动就启动 Activity 的应用 使用通知触发的 Activity

不可重置的硬件标识符

针对访问设备序列号和 IMEI 实施了限制 访问设备序列号或 IMEI 的应用 使用用户可以重置的标识符

无线扫描权限

访问某些 WLAN、WLAN 感知和蓝牙扫描方法需要获得精确位置权限 使用 WLAN API 和蓝牙 API 的应用 针对相关使用场景请求 ACCESS_FINE_LOCATION 权限

1.1.2更多隐私权变更

标识符和数据： 针对硬件标识符（如 IMEI、序列号、MAC 和类似数据）实施了新限制。

移除了联系人亲密程度信息

随机分配 MAC 地址

对 /proc/net 文件系统的访问权限实施了限制

对不可重置的设备标识符实施了限制

限制了对剪贴板数据的访问权限

保护 USB 设备序列号

摄像头和连接性： 针对摄像头元数据和连接 API 提供了更强大的保护措施。 对访问摄像头详情和元数据的权限实施了限制

对启用和停用 WLAN 实施了限制

对直接访问已配置的 WLAN 网络实施了限制

一些电话 API、蓝牙 API 和 WLAN API 需要精确位置权限

权限 ： 针对权限模型和要求的一些变更。

限制对屏幕内容的访问

面向用户的权限检查（针对旧版应用）

身体活动识别

从界面中移除了权限组

1.2影响应用的行为变更

文档： https://developer.android.google.cn/about/versions/10/behavior-changes-all?hl=zh_cn

限制非 SDK 接口： 为了帮助确保应用的稳定性和兼容性，Android 平台开始限制应用在 Android 9（API 级别 28）中使用非 SDK 接口。Android 10 包含更新后的受限制非 SDK 接口列表（基于与 Android 开发者之间的协作以及最新的内部测试）。我们的目标是在限制使用非 SDK 接口之前确保有可用的公开替代方案。

手势导航： 从 Android 10 开始，用户可以在设备中启用手势导航。用户启用后，手势导航会影响设备上的所有应用，无论应用是否以 API 级别 29 为目标平台。例如，如果用户从屏幕边缘向内滑动，系统会将该手势解读为“返回”导航，除非应用针对屏幕的相应部分明确替换该手势。

NDK 方面的变更

共享对象不得包含文本重定位

Bionic 库和动态链接器路径变更

系统二进制文件/库会映射到只执行内存

安全方面的变更

 TLS 1.3 默认处于启用状态

TLS 不信任使用 SHA-1 签名的证书

KeyChain 行为变更和改进

其他 TLS 和加密更改

WLAN 直连广播

在 Android 10 中，以下与 WLAN 直连相关的广播不具有粘性：

WIFI_P2P_CONNECTION_CHANGED_ACTION

WIFI_P2P_THIS_DEVICE_CHANGED_ACTION

如果的应用依赖于在注册时接收这些广播（因为其之前一直具有粘性），请在初始化时使用适当的 get() 方法获取信息。

WLAN 感知功能  

Android 10 扩大了支持范围，现在可以使用 WLAN 感知数据路径轻松创建 TCP/UDP 套接字。要创建连接到 ServerSocket 的 TCP/UDP 套接字，客户端设备需要知道服务器的 IPv6 地址和端口。这在之前需要通过频外方式进行通信（例如使用 BT 或 WLAN 感知第 2 层消息传递），或者使用其他协议（例如 mDNS）通过频内方式发现。而借助 Android 10，可以将此类消息作为网络设置的一部分进行传递。

Go 设备上的 SYSTEM_ALERT_WINDOW

在 Android 10（Go 版本）设备上运行的应用无法获得 SYSTEM_ALERT_WINDOW 权限。这是因为绘制叠加层窗口会使用过多的内存，这对低内存 Android 设备的性能十分有害。

如果在搭载 Android 9 或更低版本的 Go 版设备上运行的应用获得了 SYSTEM_ALERT_WINDOW 权限，则即使设备升级到 Android 10，也会保留此权限。不过，尚不具有此权限的应用在设备升级后便无法获得此权限了。

如果 Go 设备上的应用发送具有 ACTION_MANAGE_OVERLAY_PERMISSION 操作的 intent，则系统会自动拒绝此请求，并将用户转到设置屏幕，上面会显示不允许授予此权限，原因是它会减慢设备的运行速度。如果 Go 设备上的应用调用 Settings.canDrawOverlays()，则此方法始终返回 false。同样，这些限制不适用于在设备升级到 Android 10 之前便已收到 SYSTEM_ALERT_WINDOW 权限的应用。

关于以旧版 Android 系统为目标平台的应用的警告

在搭载 Android 10 或更高版本的设备上，如果用户首次运行以 Android 5.1（API 级别 22）或更低版本为目标平台的应用，则会看到警告。如果此应用要求用户授予权限，则系统会先向用户提供调整应用权限的机会，然后才会允许此应用首次运行。

由于 Google Play 的目标 API 方面的要求，用户只有在运行最近未更新的应用时才会看到这些警告。对于通过其他商店分发的应用，我们也将于 2019 年引入类似的目标 API 方面的要求。如需详细了解这些要求，请参阅在 2019 年扩展目标 API 级别方面的要求。

移除了 SHA-2 CBC 加密套件

以下 SHA-2 CBC 加密套件已从平台中移除：

TLS_RSA_WITH_AES_128_CBC_SHA256

TLS_RSA_WITH_AES_256_CBC_SHA256

TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256

TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384

TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256

TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384

这些加密套件不如使用 GCM 的类似加密套件安全，并且大多数服务器要么同时支持这些加密套件的 GCM 变体和 CBC 变体，要么二者均不支持。

应用使用情况的变更

UsageStats 应用使用情况方面的改进 - 当在分屏或画中画模式下使用应用时，Android 10 现在能够使用 UsageStats 准确地跟踪应用使用情况。此外，Android 10 可以正确地跟踪免安装应用的使用情况。

按应用开启灰度模式 - Android 10 可针对各个应用设置灰度显示模式。

按应用开启干扰模式 - Android 10 可以选择性地将应用设置为“干扰模式”，此时系统会禁止显示其通知，并且不会将其显示为推荐的应用。

暂停和播放 - 在 Android 10 中，暂停的应用无法播放音频。

HTTPS 连接变更

如果在 Android 10 上运行的应用将 null 传递给 setSSLSocketFactory()，则会出现 IllegalArgumentException。在以前的版本中，将 null 传递给 setSSLSocketFactory() 与传入当前的默认 SSL 套接字工厂效果相同。

android.preference 库已弃用

从 Android 10 开始，将弃用 android.preference 库。开发者应该改为使用 AndroidX preference 库，这是 Android Jetpack 的一部分。如需获取其他有助于迁移和开发的资源，请查看经过更新的设置指南以及我们的公开示例应用和参考文档。

ZIP 文件实用程序库变更

Android 10 对 java.util.zip 软件包（用于处理 ZIP 文件）中的类进行了以下变更。这些变更会让库的行为在 Android 和使用 java.util.zip 的其他平台之间更加一致。

Inflater

在以前的版本中，如果在调用 end() 之后调用 Inflater 类中的某些方法，这些方法会抛出 IllegalStateException。在 Android 10 中，这些方法会改为抛出 NullPointerException。

ZipFile

在 Android 10 及更高版本中，如果所提供的 ZIP 文件不包含任何文件，则 ZipFile 的构造函数（采用的参数类型为 File、int 和 Charset）不会抛出 ZipException。

ZipOutputStream

在 Android 10 及更高版本中，如果 ZipOutputStream 中的 finish() 方法尝试为不包含任何文件的 ZIP 文件写入输出流，则此方法不会抛出 ZipException。

摄像头变更

很多使用摄像头的应用都会假定如果设备采用纵向配置，则物理设备也会处于纵向，正如摄像头方向中所述。在过去可以做出这样的假定，但随着可用的设备类型（例如可折叠设备）的扩展，这一情况发生了变化。针对这些设备做出这样的假定可能导致相机取景器的显示产生错误的旋转和/或缩放。

以 API 级别 24 或更高级别为目标平台的应用应该明确设置 android:resizeableActivity，并提供必要的功能来处理多窗口操作。

电池用量跟踪

从 Android 10 开始，只要在发生重大充电事件之后拔下设备电源插头，SystemHealthManager 就会重置其电池用量统计信息。一般来说，重大充电事件指的是设备电池已充满，或者设备电量从几乎耗尽变为即将充满。

在 Android 10 之前，无论何时拔下设备电源插头，无论电池电量有多微小的变化，电池用量统计信息都会重置。

Android Beam 已弃用

在 Android 10 中，我们正式弃用了 Android Beam，这是一项旧版功能，可通过近距离无线通信 (NFC) 在多个设备之间启动数据共享。我们还弃用了一些相关的 NFC API。Android Beam 仍可供需要的设备制造商合作伙伴使用，但它已不再处于积极的开发阶段。不过，Android 仍将继续支持其他的 NFC 功能和 API，并且从标签和付款中读取数据等使用场景仍将继续按预期执行。

Ⅲ 如何搭建 android 开发环境

一.认识android的架构
Android其本质就是在标准的Linux系统上增加了Java虚拟机Dalvik，并在Dalvik虚拟机上搭建了一个JAVA的application framework，所有的应用程序都是基于JAVA的application framework之上。
android分为四个层，从高层到低层分别是应用程序层、应用程序框架层、系统运行库层和linux核心层。
二.搭建环境
搭建开发环境
对国内的开发者来说最痛苦的是无法去访问android开发网站。为了更好的认识世界，对程序员来说，会翻墙也是的一门技术，带你去领略墙外的世界，好了，不废话了, 国内开发者访问(androiddevtools) 上面已经有了所有你要的资源，同时可以下载到我们的主角framework
但是这样的搭建只能去阅读源代码，我们无法去更进一步去实现自己的rom,我们看到锤子的系统在早期的开放rom是自己从新实现了framework的代码，现在看起来他成功了，所以我们还要去搭建android系统的源码编译环境。
搭建源码编译环境

三.开始主题
在一开始写c程序的时候都有一个运行的入口，比如
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
//这里的main就是应用的入口
int main(int argc, const char * argv[]){
return 0;
}
在计算机网络原理中我们用socket实现一个服务器端，不断的接听客户端的访问，而且他的代码是这样实现的：
#include <winsock2.h>
#pragma comment(lib, "WS2_32.lib")
#include <stdio.h>
void main()
{
WORD wVersionRequested;//版本号
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字
//加载套接字库,如果失败返回
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0)
{
return;
}
//判断高低字节是不是2,如果不是2.2的版本则退出
if (LOBYTE(wsaData.wVersion) != 2 ||
HIBYTE(wsaData.wVersion) != 2)
{
return;
}
//创建流式套接字,基于TCP(SOCK_STREAM)
SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);
//Socket地址结构体的创建
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格
addrSrv.sin_family = AF_INET;//指定地址簇
addrSrv.sin_port = htons(6000);
//指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换
//将套接字绑定到一个端口号和本地地址上
bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行
listen(socSrv, 5);
SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体
int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof
//循环等待接受客户端发送请求
while (1)
{
//等待客户请求到来；当请求到来后，接受连接请求，
//返回一个新的对应于此次连接的套接字（accept）。
//此时程序在此发生阻塞
SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);
char sendBuf[100];
sprintf(sendBuf, "Welcome %s to JoyChou",
inet_ntoa(addrClient.sin_addr));//格式化输出
//用返回的套接字和客户端进行通信
send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节
//接收数据
char recvBuf[100];
recv(sockConn, recvBuf, 100, 0);
printf("%s\\n", recvBuf);
closesocket(sockConn);
}
}
他采用了一个while死循环去监听客户端的请求。

先上源代码
public final class ActivityThread {
public static void main(String[] args) {
SamplingProfilerIntegration.start();
CloseGuard.setEnabled(false);
Environment.initForCurrentUser();
EventLogger.setReporter(new EventLoggingReporter());
Security.addProvider(new AndroidKeyStoreProvider());
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
//从中可以看到为app开辟了一个线程进入了looper之中
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}
看到源码失望了，没有一个while循环啊，其实用了他方法实现
//用一个looper的机制循环监听响应
Looper.prepareMainLooper();
Looper.loop();
进一步深入代码
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 在这里看到了一个循环监听消息
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg);
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that ring 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();
}
}

Ⅳ android如何实现图片批量上传

首先，以下架构下的批量文件上传可能会失败或者不会成功：
1.android客户端+springMVC服务端：服务端采用org.springframework.web.multipart.MultipartHttpServletRequest作为批量上传接收类，这种搭配下的批量文件上传会失败，最终服务端只会接受到一个文件，即只会接受到第一个文件。可能因为MultipartHttpServletRequest对servlet原本的HttpServletRequest类进行封装，导致批量上传有问题。
2.android客户端+strutsMVC服务端：
上传成功的方案：
采用android客户端+Servlet（HttpServletRequest）进行文件上传。
Servlet端代码如下：

[java] view plainprint?
DiskFileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
try
{
List items = upload.parseRequest(request);
Iterator itr = items.iterator();
while (itr.hasNext())
{
FileItem item = (FileItem) itr.next();
if (item.isFormField())
{
System.out.println("表单参数名:" + item.getFieldName() + "，表单参数值:" + item.getString("UTF-8"));
}
else
{
if (item.getName() != null && !item.getName().equals(""))
{
System.out.println("上传文件的大小:" + item.getSize());
System.out.println("上传文件的类型:" + item.getContentType());
// item.getName()返回上传文件在客户端的完整路径名称
System.out.println("上传文件的名称:" + item.getName());

File tempFile = new File(item.getName());
// 上传文件的保存路径
File file = new File(sc.getRealPath("/") + savePath, tempFile.getName());
item.write(file);
request.setAttribute("upload.message", "上传文件成功！");
} else
{
request.setAttribute("upload.message", "没有选择上传文件！");
}
}
}
}
catch (FileUploadException e)
{
e.printStackTrace();
}
catch (Exception e)
{
e.printStackTrace();
request.setAttribute("upload.message", "上传文件失败！");
}
request.getRequestDispatcher("/uploadResult.jsp").forward(request, response);

android端代码如下：

[java] view plainprint?
public class SocketHttpRequester {
/**
*多文件上传
* 直接通过HTTP协议提交数据到服务器,实现如下面表单提交功能:
* <FORM METHOD=POST ACTION="http://192.168.1.101:8083/upload/servlet/UploadServlet" enctype="multipart/form-data">
<INPUT TYPE="text" NAME="name">
<INPUT TYPE="text" NAME="id">
<input type="file" name="imagefile"/>
<input type="file" name="zip"/>
</FORM>
* @param path 上传路径(注：避免使用localhost或127.0.0.1这样的路径测试，因为它会指向手机模拟器，你可以使用http://www.iteye.cn或http://192.168.1.101:8083这样的路径测试)
* @param params 请求参数 key为参数名,value为参数值
* @param file 上传文件
*/
public static boolean post(String path, Map<String, String> params, FormFile[] files) throws Exception{
final String BOUNDARY = "---------------------------7da2137580612"; //数据分隔线
final String endline = "--" + BOUNDARY + "--\r\n";//数据结束标志

int fileDataLength = 0;
for(FormFile uploadFile : files){//得到文件类型数据的总长度
StringBuilder fileExplain = new StringBuilder();
fileExplain.append("--");
fileExplain.append(BOUNDARY);
fileExplain.append("\r\n");
fileExplain.append("Content-Disposition: form-data;name=\""+ uploadFile.getParameterName()+"\";filename=\""+ uploadFile.getFilname() + "\"\r\n");
fileExplain.append("Content-Type: "+ uploadFile.getContentType()+"\r\n\r\n");
fileExplain.append("\r\n");
fileDataLength += fileExplain.length();
if(uploadFile.getInStream()!=null){
fileDataLength += uploadFile.getFile().length();
}else{
fileDataLength += uploadFile.getData().length;
}
}
StringBuilder textEntity = new StringBuilder();
for (Map.Entry<String, String> entry : params.entrySet()) {//构造文本类型参数的实体数据
textEntity.append("--");
textEntity.append(BOUNDARY);
textEntity.append("\r\n");
textEntity.append("Content-Disposition: form-data; name=\""+ entry.getKey() + "\"\r\n\r\n");
textEntity.append(entry.getValue());
textEntity.append("\r\n");
}
//计算传输给服务器的实体数据总长度
int dataLength = textEntity.toString().getBytes().length + fileDataLength + endline.getBytes().length;

URL url = new URL(path);
int port = url.getPort()==-1 ? 80 : url.getPort();
Socket socket = new Socket(InetAddress.getByName(url.getHost()), port);
OutputStream outStream = socket.getOutputStream();
//下面完成HTTP请求头的发送
String requestmethod = "POST "+ url.getPath()+" HTTP/1.1\r\n";
outStream.write(requestmethod.getBytes());
String accept = "Accept: image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*\r\n";
outStream.write(accept.getBytes());
String language = "Accept-Language: zh-CN\r\n";
outStream.write(language.getBytes());
String contenttype = "Content-Type: multipart/form-data; boundary="+ BOUNDARY+ "\r\n";
outStream.write(contenttype.getBytes());
String contentlength = "Content-Length: "+ dataLength + "\r\n";
outStream.write(contentlength.getBytes());
String alive = "Connection: Keep-Alive\r\n";
outStream.write(alive.getBytes());
String host = "Host: "+ url.getHost() +":"+ port +"\r\n";
outStream.write(host.getBytes());
//写完HTTP请求头后根据HTTP协议再写一个回车换行
outStream.write("\r\n".getBytes());
//把所有文本类型的实体数据发送出来
outStream.write(textEntity.toString().getBytes());
//把所有文件类型的实体数据发送出来
for(FormFile uploadFile : files){
StringBuilder fileEntity = new StringBuilder();
fileEntity.append("--");
fileEntity.append(BOUNDARY);
fileEntity.append("\r\n");
fileEntity.append("Content-Disposition: form-data;name=\""+ uploadFile.getParameterName()+"\";filename=\""+ uploadFile.getFilname() + "\"\r\n");
fileEntity.append("Content-Type: "+ uploadFile.getContentType()+"\r\n\r\n");
outStream.write(fileEntity.toString().getBytes());
if(uploadFile.getInStream()!=null){
byte[] buffer = new byte[1024];
int len = 0;
while((len = uploadFile.getInStream().read(buffer, 0, 1024))!=-1){
outStream.write(buffer, 0, len);
}
uploadFile.getInStream().close();
}else{
outStream.write(uploadFile.getData(), 0, uploadFile.getData().length);
}
outStream.write("\r\n".getBytes());
}
//下面发送数据结束标志，表示数据已经结束
outStream.write(endline.getBytes());

BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
if(reader.readLine().indexOf("200")==-1){//读取web服务器返回的数据，判断请求码是否为200，如果不是200，代表请求失败
return false;
}
outStream.flush();
outStream.close();
reader.close();
socket.close();
return true;
}

/**
*单文件上传
* 提交数据到服务器
* @param path 上传路径(注：避免使用localhost或127.0.0.1这样的路径测试，因为它会指向手机模拟器，你可以使用http://www.itcast.cn或http://192.168.1.10:8080这样的路径测试)
* @param params 请求参数 key为参数名,value为参数值
* @param file 上传文件
*/
public static boolean post(String path, Map<String, String> params, FormFile file) throws Exception{
return post(path, params, new FormFile[]{file});
}
}

Ⅳ android 开发框架有哪些

主要总结了7个好用的android 开发框架推荐给你：
一、 Afinal

Afinal是一个Android的ioc，orm框架，内置了四大模块功能：FinalAcitivity,FinalBitmap,FinalDb,FinalHttp。通过finalActivity，我们可以通过注解的方式进行绑定ui和事件。通过finalBitmap，我们可以方便的加载bitmap图片，而无需考虑oom等问题。通过finalDB模块，我们一行代码就可以对android的sqlite数据库进行增删改查。通过FinalHttp模块，我们可以以ajax形式请求http数据。

功能：

一个android的ioc，orm框架，内置了四大模块功能：FinalAcitivity,FinalBitmap,FinalDb,FinalHttp。通过finalActivity，我们可以通过注解的方式进行绑定ui和事件。通过finalBitmap，我们可以方便的加载bitmap图片，而无需考虑oom等问题。通过finalDB模块，我们一行代码就可以对android的sqlite数据库进行增删改查。通过FinalHttp模块，我们可以以ajax形式请求http数据。

优点：功能比较全面，文档完善，代码效率比较高。

缺点：没有项目demo，框架的时间比较久，代码冗余比较多(这也是无可避免的)，文档比较老跟不上代码更新进度。

二、 xUtils

xUtils：可以说是Afinal的升级版。

xUtils 包含了很多实用的android工具。

xUtils 支持大文件上传，更全面的http请求协议支持(10种谓词)，拥有更加灵活的ORM，更多的事件注解支持且不受混淆影响...

xUitls 最低兼容android 2.2 (api level 8)

三、 ThinkAndroid

ThinkAndroid是一个免费的开源的、简易的、遵循Apache2开源协议发布的Android开发框架，其开发宗旨是简单、快速的进行Android应用程序的开发，包含Android
mvc、简易sqlite orm、ioc模块、封装Android
httpclitent的http模块,具有快速构建文件缓存功能，无需考虑缓存文件的格式，都可以非常轻松的实现缓存，它还基于文件缓存模块实现了图片缓存功能，在android中加载的图片的时候，对oom的问题，和对加载图片错位的问题都轻易解决。他还包括了一个手机开发中经常应用的实用工具类，如日志管理，配置文件管理，android下载器模块，网络切换检测等等工具

四、 LoonAndroid

如果你想看ui方面的东西，这里没有，想要看牛逼的效果这里也没有。这只是纯实现功能的框架，它的目标是节省代码量，降低耦合，让代码层次看起来更清晰。整个框架一部分是网上的，一部分是我改的，为了适应我的编码习惯，还有一部分像orm完全是网上的组件。在此感谢那些朋友们。
整个框架式的初衷是为了偷懒，之前都是一个功能一个jar，做项目的时候拉进去，这样对于我来说依然还是比较麻烦。最后就导致我把所有的jar做成了一个工具集合包。
有很多框架都含有这个工具集合里的功能，这些不一定都好用，因为这是根据我个人使用喜欢来实现的，如果你们有自己的想法，可以自己把架包解压了以后，源码拉出来改动下。
目前很多框架都用到了注解，除了androidannotations没有入侵我们应用的代码以外，其他的基本上都有，要么是必须继承框架里面的activity,要么是必须在activity的oncreat里面调用某个方法。
整个框架式不同于androidannotations，Roboguice等ioc框架，这是一个类似spring的实现方式。在整应用的生命周期中找到切入点，然后对activity的生命周期进行拦截，然后插入自己的功能。

五、 KJFrameForAndroid

KJFrameForAndroid 又叫KJLibrary，是一个android的orm 和 ioc
框架。同时封装了android中的Bitmap与Http操作的框架，使其更加简单易用;

KJFrameForAndroid的设计思想是通过封装Android原生SDK中复杂的复杂操作而达到简化Android应用级开发，最终实现快速而又安全的开发APP。我们提倡用最少的代码，完成最多的操作，用最高的效率，完成最复杂的功能。

功能：

一个android的orm 和 ioc 框架。同时封装了android中的Bitmap与Http操作的框架，使其更加简单易用;
KJFrameForAndroid开发框架的设计思想是通过封装Android原生SDK中复杂的复杂操作而达到简化Android应用级开发，最终实现快速而又安全的开发APP。总共分为五大模块：UILibrary，UtilsLibrary，HttpLibrary，BitmapLibrary，DBLibrary。

六、 dhroid

dhroid 是基于android 平台,
极速开发框架，其核心设计目标是开发迅速、代码量少、学习简单、功能强大、轻量级、易扩展.使你更快,更好的开发商业级别应用

功能：

1.Ioc容器: (用过spring的都知道)视图注入,对象注入,接口注入,解决类依赖关系

2.Eventbus: android平台事件总线框架,独创延时事件,事件管理轻松

3.Dhnet: 网络http请求的解决方案,使用简单,减少代码,自带多种网络访问缓存策略

4.adapter模块: 数据绑定轻松,不用写多余的adapter,天生网络支持(一行代码搞定加载,刷新问题)

5.DhDb: android中sqlite的最轻量orm框架(增删改查轻松搞定)

6.Perference: android自带Perference 升级版,让你的Perference更强大,更方便

工具集合 JSONUtil(安全处理json),ViewUtil(数据绑定更快) ThreadWorker(异步任务工具)...

七、 SmartAndroid

SmartAndroid是一套给
Android开发者使用的应用程序开发框架和工具包。它提供一套丰富的标准库以及简单的接口和逻辑结构，其目的是使开发人员更快速地进行项目开发。使用
SmartAndroid可以减少代码的编写量，并将你的精力投入到项目的创造性开发上。

功能：

SmartAndroid 拥有全范围的类库，可以完成大多数通常需要的APP开发任务，包括：
异步网络操作相关所有功能、强大的图片处理操作、轻量级ORM数据库Sqlite库、zip操作
、动画特效、Html等解析采集、事件总线EventBus/Otto、Gson(Json)、AQuery、主流所有UI控件(例如：ActionbarSherlock，SlidingMenu，BottomView，Actionbar，DragListView等10多种UI库)等。

Ⅵ 后端服务器返回给android应用程序的数据格式通常是

通常是以下几种：
1、json。
2、arraybuffer。
3、blob。
4、document。
5、text。
6、stream。

Ⅶ android 网络请求数据一般写在哪

在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通过回调方法处理请求结果。

其主要特征如下：

■处理异步Http请求，并通过匿名内部类处理回调结果
■Http请求均位于非UI线程，不会阻塞UI操作
■通过线程池处理并发请求
■处理文件上传、下载
■响应结果自动打包JSON格式
■自动处理连接断开时请求重连
使用android-async-http也非常简单，到官网下载依赖jar包，导入工程中libs文件夹下并添加到工程路径即可。

Ⅷ 安卓如何扩展输出

选择设备的工作基本就做完了，但是前提是需要j从ava层到framework层为该音频类型打通过程。实际上这个参照一种音频类型的实现就很容易解决。基本上理清一个audiotrack从java层到native层的调用过程即可，在java层audiomanger与audiosystem中添加我们自定义的音频类型之后来看audiotrack的构造函数，5.1之于4.4多了一个AudioAttributes，这对上层传下来的streamType做了一层封装，看上去是更方便了我们的扩展，通过上层stream_type转化得到 private int mUsage = USAGE_UNKNOWN;

和 private int mContentType = CONTENT_TYPE_UNKNOWN两种类型，到了native层AudioTrack.cpp的set函数中：

status_t AudioTrack::set(

audio_stream_type_t streamType,

uint32_t sampleRate,

audio_format_t format,

audio_channel_mask_t channelMask,

size_t frameCount,

audio_output_flags_t flags,

callback_t cbf,

void* user,

uint32_t notificationFrames,

const sp& sharedBuffer,

bool threadCanCallJava,

int sessionId,

transfer_type transferType,

const audio_offload_info_t *offloadInfo,

int uid,

pid_t pid,

const audio_attributes_t* pAttributes)

{

ALOGI("set(): %p streamType %d, sampleRate %u, format %#x, channelMask %#x, frameCount %zu, "

"flags #%x, notificationFrames %u, sessionId %d, transferType %d",

this,streamType, sampleRate, format, channelMask, frameCount, flags, notificationFrames,

sessionId, transferType);

switch (transferType) {

case TRANSFER_DEFAULT:

if (sharedBuffer != 0) {

transferType = TRANSFER_SHARED;

} else if (cbf == NULL || threadCanCallJava) {

transferType = TRANSFER_SYNC;

} else {

transferType = TRANSFER_CALLBACK;

}

break;

case TRANSFER_CALLBACK:

if (cbf == NULL || sharedBuffer != 0) {

ALOGE("Transfer type TRANSFER_CALLBACK but cbf == NULL || sharedBuffer != 0");

return BAD_VALUE;

}

break;

case TRANSFER_OBTAIN:

case TRANSFER_SYNC:

if (sharedBuffer != 0) {

ALOGE("Transfer type TRANSFER_OBTAIN but sharedBuffer != 0");

return BAD_VALUE;

}

break;

case TRANSFER_SHARED:

if (sharedBuffer == 0) {

ALOGE("Transfer type TRANSFER_SHARED but sharedBuffer == 0");

return BAD_VALUE;

}

break;

default:

ALOGE("Invalid transfer type %d", transferType);

return BAD_VALUE;

}

mSharedBuffer = sharedBuffer;

mTransfer = transferType;

ALOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(),

sharedBuffer->size());

ALOGV("set() streamType %d frameCount %zu flags %04x", streamType, frameCount, flags);

AutoMutex lock(mLock);

// invariant that mAudioTrack != 0 is true only after set() returns successfully

if (mAudioTrack != 0) {

ALOGE("Track already in use");

return INVALID_OPERATION;

}

// handle default values first.

if (streamType == AUDIO_STREAM_DEFAULT) {

streamType = AUDIO_STREAM_MUSIC;

}

if (pAttributes == NULL) {

if (uint32_t(streamType) >= AUDIO_STREAM_PUBLIC_CNT) {

ALOGE("Invalid stream type %d", streamType);

return BAD_VALUE;

}

mStreamType = streamType;

} else {

// stream type shouldn't be looked at, this track has audio attributes

memcpy(&mAttributes, pAttributes, sizeof(audio_attributes_t));

ALOGV("Building AudioTrack with attributes: usage=%d content=%d flags=0x%x tags=[%s]",

mAttributes.usage, mAttributes.content_type, mAttributes.flags, mAttributes.tags);

mStreamType = AUDIO_STREAM_DEFAULT;

}

// these below should probably come from the audioFlinger too...

if (format == AUDIO_FORMAT_DEFAULT) {

format = AUDIO_FORMAT_PCM_16_BIT;

}

......看到 mStreamType = AUDIO_STREAM_DEFAULT; stream_type已经被设为-1，后面获取设备时不再关心stream_type,而是由audio_attributes_t这个结构体来选择，再来看看这个结构体的定义：

typedef struct {

audio_content_type_t content_type;

audio_usage_t usage;

audio_source_t source;

audio_flags_mask_t flags;

char tags[AUDIO_ATTRIBUTES_TAGS_MAX_SIZE]; /* UTF8 */

} audio_attributes_t;

正是前面提到的mUsage 和mContentType 。

再回到AudioPolicyManager，看看getOutputForAttr接口，改接口调用了我们之前修改过的getDeviceForStrategy来获取设备：

......

ALOGV("getOutputForAttr() usage=%d, content=%d, tag=%s flags=%08x",

attributes.usage, attributes.content_type, attributes.tags, attributes.flags);

routing_strategy strategy = (routing_strategy) getStrategyForAttr(&attributes);

audio_devices_t device = getDeviceForStrategy(strategy, false /*fromCache*/);

...... 所以在上层将stream_type 与AudioAttributes的转换做好，这条路就基本打通了，双音频输出的功能就实现了。

Ⅸ Android 如何触发打开文件

<activity android:name=".EasyNote" android:label="@string/app_name" android:launchMode="singleTask" android:screenOrientation="portrait">
< intent-filter>
< action android:name="android.intent.action.MAIN" />
< category android:name="android.intent.category.LAUNCHER" />
< /intent-filter>
<intent-filter>
< action android:name="android.intent.action.VIEW"></action>
< category android:name="android.intent.category.DEFAULT"></category>
< data android:mimeType="text/plain"></data>
< /intent-filter>
< /activity>
第一个<intent-filter>标签是每个程序都有的，关键是要添加第二个！这样你的应用程序就会出现在默认打开列表了。。。

注意需要将mimeType修改成你需要的类型，文本文件当然就是：text/plain

还有其它常用的如：

text/plain（纯文本）

text/html（HTML文档）

application/xhtml+xml（XHTML文档）

image/gif（GIF图像）

image/jpeg（JPEG图像）【PHP中为：image/pjpeg】

image/png（PNG图像）【PHP中为：image/x-png】

video/mpeg（MPEG动画）

application/octet-stream（任意的二进制数据）

application/pdf（PDF文档）

application/msword（Microsoft Word文件）

message/rfc822（RFC 822形式）

multipart/alternative（HTML邮件的HTML形式和纯文本形式，相同内容使用不同形式表示）

application/x-www-form-urlencoded（使用HTTP的POST方法提交的表单）

multipart/form-data（同上，但主要用于表单提交时伴随文件上传的场合）