Mange nye domener frigitt!
Kontakt oss for hjelp til registrering av disse domenene, om du vet om et domene som ikke finnes i listen kan du også ta kontakt så hjelper vi deg å megle det.
biocid.no
karse.no
biologisk.no
beskjed.no
chicago.no
tastatur.no
sentralt.no
tøyen.no
skrivemaskinen.no
desiderata.no
røt.no
maskin.no
svampen.no
bokhandleren.no
håp.no
moderat.no
lærerikt.no
karat.no
scenen.no
skjell.no
algebra.no
arabesk.no
fysisk.no
neshorn.no
kondensator.no
romaner.no
fyllepenn.no
røyk.no
tingene.no
trilogi.no
deodorant.no
gullsmeder.no
kremen.no
knipset.no
matematisk.no
byggverket.no
avmakt.no
rotor.no
førsteklasses.no
fotografert.no
faderen.no
partiet.no
geometri.no
fugleskremsel.no
egoist.no
personbil.no
inflasjon.no
knabben.no
biennale.no
erfare.no
destinasjon.no
importvarer.no
funksjoner.no
indiske.no
ekteskap.no
perpleks.no
kjemisk.no
tropisk.no
trase.no
tramp.no
pilk.no
54.no
2p.no
1u.no
duke.no
skut.no
hamp.no
sur.no
63.no
6d.no
6f.no
8u.no
0o.no
7y.no
Two Simple Questions
And the answers to them, posted here and there by senior Android engineers.
How much memory is my app using?
Over at Stack Overflow, our own Dianne Hackborn takes this up in detail. There’s no simple answer, but Dianne does offer lots of useful information.
How do I make a ScrollView behave?
This one does have a simple answer, and our Romain Guy offers it in ScrollView’s handy trick. It’s easy enough to do once you know how, which is harder to find out than you might think, because there’s one useful XML attribute that’s there in the examples but missing in the docs. Oops!
See more here: Two Simple Questions
A Little Too Popular
A couple of weeks ago, we arranged that registered developers could buy an unlocked Nexus One via their publisher page in Android Market. We think it’s a good development platform and a nice phone. Apparently, you agree. Somewhat too many of you, in fact; we blew through the (substantial) initial inventory in almost no time, and they’re back-ordered from HTC, who are doing a pretty good job of managing runaway success amid a worldwide AMOLED shortage. Everyone appreciates that it’s important to the platform to get phones in the hands of developers, so we’re working hard on re-stocking the shelves; stand by.
Continued here: A Little Too Popular
Licensing Server News
It’s been reported that someone has figured out, and published, a way to hack some Android apps to bypass our new Android Market licensing server. We’ll be saying more on this, but there are a few points that deserve to be made right now:
-
The licensing service, while very young, is a significant step forward in terms of protection over the plain copy-protection facility that used to be the norm. In the how-to-pirate piece, its author wrote: “For now, Google’s Licensing Service is still, in my opinion, the best option for copy protection.”
-
The licensing service provides infrastructure that developers can use to write custom authentication checks for each of their applications. The first release shipped with the simplest, most transparent imaginable sample implementation, which was written to be easy to understand and modify, rather than security-focused.
-
Some developers are using this sample as-is, which makes their applications easier to attack. The attacks we’ve seen so far are also all on applications that have neglected to obfuscate their code, a practice that we strongly recommend. We’ll be publishing detailed instructions for developers on how to do this.
-
The number of apps that have migrated to the licensing server at this point in time is very small. It will grow, because the server is a step forward.
-
100% piracy protection is never possible in any system that runs third-party code, but the licensing server, when correctly implemented and customized for your app, is designed to dramatically increase the cost and difficulty of pirating.
-
The best attack on pirates is to make their work more difficult and expensive, while simultaneously making the legal path to products straightforward, easy, and fast. Piracy is a bad business to be in when the user has a choice between easily purchasing the app and visiting an untrustworthy, black-market site.
Android Market is already a responsive, low-friction, safe way for developer to get their products to users. The licensing server makes it safer, and we will continue to improve it. The economics are already working for the developers and against the pirates, and are only going to tilt further in that direction.
See original here: Licensing Server News
Securing Android LVL Applications
[This post is by Trevor Johns, who's a Developer Programs Engineer working on Android. — Tim Bray]
The Android Market licensing service is a powerful tool for protecting your applications against unauthorized use. The License Verification Library (LVL) is a key component. A determined attacker who’s willing to disassemble and reassemble code can eventually hack around the service; but application developers can make the hackers’ task immensely more difficult, to the point where it may simply not be worth their time.
Out of the box, the LVL protects against casual piracy; users who try to copy APKs directly from one device to another without purchasing the application. Here are some techniques to make things hard, even for technically skilled attackers who attempt to decompile your application and remove or disable LVL-related code.
-
You can obfuscate your application to make it difficult to reverse-engineer.
-
You can modify the licensing library itself to make it difficult to apply common cracking techniques.
-
You can make your application tamper-resistant.
-
You can offload license validation to a trusted server.
This can and should be done differently by each app developer. A guiding principle in the design of the licensing service is that attackers must be forced to crack each application individually, and unfortunately no client-side code can be made 100% secure. As a result, we depend on developers introducing additional complexity and heterogeneity into the license check code
Brace for the Future
[This post is by Dan Morrill, Open Source & Compatibility Program Manager. — Tim Bray]
Way back in November 2007 when Google announced Android, Andy Rubin said “We hope thousands of different phones will be powered by Android.” But now, Android’s growing beyond phones to new kinds of devices. (For instance, you might have read about the new 7” Galaxy Tab that our partners at Samsung just announced.) So, I wanted to point out a few interesting new gadgets that are coming soon running the latest versions of Android, 2.1 and 2.2.
For starters, the first Android-based non-phone handheld devices will be shipping over the next few months. Some people call these Mobile Internet Devices or Personal Media Players
One Screen Turn Deserves Another
[This post is by Dan Morrill, Open Source & Compatibility Program Manager. — Tim Bray]
Android has an API for accessing a variety of sensor types, such as an accelerometer or light sensor. Two of the most commonly-used sensors are accelerometers and magnetometers (that is, compasses.) Applications and devices frequently use these as forms of user input, and to determine which way to orient the screen.
However, there’s a new wrinkle: recently, a few devices have shipped (see here and here) that run Android on screens that are naturally landscape in their orientation. That is, when held in the default position, the screens are wider than they are tall. This introduces a few fairly subtle issues that we’ve noticed causing problems in some apps. Now, part of the reason for this is that the Android SDK docs on the sensor API left a couple things unsaid, leading many developers to use them incorrectly. Even a couple of our own samples did the wrong thing. Sorry about that!
Fortunately, using these APIs correctly is pretty simple, if you keep three rules in mind:
-
The sensor coordinate system used by the API for the natural orientation of the device does not change as the device moves, and is the same as the OpenGL coordinate system.
-
Applications must not assume that the natural orientation is portrait. That’s not true on all devices.
-
Applications that match sensor data to on-screen display must always use
android.view.Display.getRotation()to map sensor coordinates to screen coordinates
Screen Geometry Fun
The recent announcement of the Samsung Galaxy Tab should be a wake-up call for Android developers. What’s scary is that we’ve never seen a screen like this on an Android device before. What’s reassuring is that most apps Just Work (in fact, a lot of the ones I’ve tried so far have looked terrific) and the potential problems are easy to avoid. Here’s what you need to do to take advantage of not just the Tab, but all the new form factors that are coming down the pipe.
Let’s consider the Tab as a “teachable moment”:
-
Its screen is 1024×600; no compatible device’s screen has ever had a thousand pixels in any dimension before.
-
A lot of people are going to want to hold it sideways, in “landscape” mode, most of the time.
We recommend spending quality time with the Developers’-guide discussion of supporting multiple screens; we’ll be revising that regularly when required as the device landscape changes. Also, this blog recently ran Dan Morrill’s One Screen Turn Deserves Another, which should help out in handling the landscape default.
What density means
When you build your app, you can provide layouts and assets (graphics) which vary by screen density, screen size, and landscape or portrait orientation. Clearly, pulling these together is not as much fun as designing groovy layouts and clever Intent filters; but there’s no way around it.
In this context, the Samsung has another little surprise: If you do the arithmetic, its screen has 170 DPI, which is far from the densest among Android devices. Still, it declares itself as “hdpi” (and as having a “large” screen size). The reason is simple: It looks better that way.
Samsung found that if you rendered your graphical resources bit-for-bit using medium-density sources, they looked great, but most large-screen designs ended up looking sparse, with too much space between buttons and icons. At high resolution, the framework scales up the resources an amount that turns out to be just enough.
As a photography hobbyist, I’m reminded of how you juggle aperture and shutter speed and ISO sensitivity. If, for example, you want a fast shutter speed to capture a dancer in mid-leap, you’d better compensate with a wider aperture or more sensitivity. Similarly, the Galaxy Tab’s screen is at the large end of “large”, so declaring it as high-density applies a useful compensation.
The good news is that the scaling code in the framework is smart enough and fast enough that it comes out well; the graphics in my own apps look remarkably good on the Tab. Here is the front page of my “LifeSaver 2” app; first the Nexus One, then the Galaxy Tab, resized for presentation here. Different densities, different geometries, and the only important difference is that the version on the big screen looks prettier.
Your take-away should be what I said above: Make sure you provide your graphics at all three resolutions, and chances are the Android framework will find a way to make them look great on a huge variety of devices.
Other Ways To Go Wrong
As I noted, most apps work just fine on this kind of device, out of the box, no changes required. However, we have run across a few Worst Practices that can make your app look dorky or even broken; for example:
-
Using AbsoluteLayout; this is a recipe for trouble.
-
Using absolute rather than density-independent pixels.
-
One member of my group ran across a couple of apps that suffered a Null Pointer Exception because they were calculating screen size when their Activity started, and doing their own resource loading rather than letting the framework take care of it. The problem was that they hadn’t built in handling for the 1024×600 screen. The problem would vanish if they’d hand the work to the framework (or at least make sure that all their
switchstatements haddefaultcases).
Escape the Shoebox
I’ve observed that a certain number of applications appear “shoeboxed”, running in a handset-like number of pixels in the center of the screen, surrounded by a wide black band. They work fine, but this is silly, and easy to avoid. It turns out that this happens when you have a targetSdkVersion value less than four; this is interpreted to mean that you’re targeting the legacy Cupcake flavor of Android, which only supported HVGA.
In any case, if you want to make 100% sure that your app doesn’t get pushed into the shoebox, the supports-screens element is your friend; here’s what we recommend:
(Both those attributes default to «false» for API levels less than 4.) Given a chance, the framework gets a good result on almost any Android screen imaginable.
Testing
When a device comes along that’s different in one way or another from what’s been available before, and you don’t have one, the only way to be sure your app will treat it properly is to run it on an Android emulator; the emulator code is flexible enough to model anything we’ve seen or know is coming down the pipe.
In the case of the Galaxy Tab, Samsung will be providing an add-on including a custom AVD and skin as an SDK add-on, to make your life easier; I used a pre-release to make the LifeSaver screenshot above.
Why All the Extra Work?
Because, as 2010 winds down, Android isn’t just for phones, and isn’t just for things that fit in your pocket. The minor effort required to deal with this should pay off big-time in terms of giving your apps access to a universe of new kinds of devices.
Read this article: Screen Geometry Fun
Supporting the new music Voice Action
[This post is by Mike LeBeau, the Tech Lead and architect behind Voice Actions. — Tim Bray]
We recently launched Voice Actions in the new Google Voice Search for Android
